<?php

namespace App\Service\CommodityService;

use App\Service\BaseService;
use App\Model\BdCommodityModel\BdSupplier;
use App\Model\CommodityModel\SupplierCompany;
use Service\AppService\IdService;
use App\Model\BdCommodityModel\BdWareHouse;
use App\Model\CommodityModel\WarehouseInfo;
use App\Model\BdCommodityModel\BdBrand;
use App\Model\CommodityModel\Brandinfo;
use App\Model\BdCommodityModel\BdClass;
use App\Model\CommodityModel\Classifyinfo;
use App\Model\BdCommodityModel\BdCountry;
use App\Model\CommodityModel\Countryinfo;
use App\Model\BdCommodityModel\BdSpu;
use App\Model\CommodityModel\CommoditySpu;
use Hyperf\DbConnection\Db;
use App\Model\BdCommodityModel\BdProduct;
use App\Model\CommodityModel\CommodityArchives;
use App\Model\BdCommodityModel\BdProductImage;
use App\Model\CommodityModel\CommodityDescription;
use App\Model\BdCommodityModel\BdAttr;
use App\Model\CommodityModel\CommoditySpecAttr;
use App\Model\BdCommodityModel\BdAttrValue;
use App\Model\CommodityModel\CommoditySpecValue;
use App\Model\CommodityModel\CommoditySpecGroup;
use App\Model\BdCommodityModel\BdUnit;
use App\Model\CommodityModel\Unitinfo;
use App\Model\BdCommodityModel\BdSkuRecord;
use App\Model\CommodityModel\SupplierCommodity;
use App\Model\BdCommodityModel\BdSku;
use App\Model\CommodityModel\Stockinfo;
use App\Model\CommodityModel\CommodityGroupAttr;
use App\Model\BdCommodityModel\BdSkuStock;
use function EasySwoole\Spl\get;
use App\Model\BdCommodityModel\BdProductSku;
use App\Model\BdCommodityModel\BdNewClass;

/**
 * 同步百大商品数据
 */
class SyncBdGoodsService extends BaseService
{
    /**
     * 同步商品基础信息
     * 分类，品牌，产地
     */
    public function startSyncBasicInfo()
    {
        //$this->syncBdBrand();
        //$this->syncBdClass();
        //$this->syncBdCountry();
        //$this->syncBdSpu();
        //$this->syncBdGoodsSku();
        //$this->syncBdGoodsSkuDesc();
        //$this->syncBdGoodsSkuAttr();
        //$this->syncBdGoodsSkuAttrValue();
        //$this->syncBdGoodsSkuAttrGroup();
        //$this->syncBdSpuAttrGroup();
        //$this->syncBdGoodsUnit();
        //$this->syncSupplierCommodity();
        //$this->startSyncCommodityStockAndPrice();
        //$this->syncNewWareHouse();
        //$this->SyncBdRepeatSku();
        //$this->startSyncCommodityStockAndPriceNew();
        //$this->SyncBdNewClass();
        /* for( $i = 0 ; $i < 1000; $i ++) 
        {
            file_put_contents("id.log",IdService::instance()->getOtherID().PHP_EOL,FILE_APPEND);
        } */
        
        $this->syncNewSkuImgDesc();
    }
    
    /**
     * 同步商品详情和轮播
     */
    public function syncNewSkuImgDesc()
    {
        $limit = 1000;
        $lastID = 0;
        while ( true )
        {
            $list = CommodityArchives::instance()
            ->select([
                'ID',
                'SKUCode',
            ])
            ->where('ID','>',$lastID)
            ->orderBy('ID','asc')
            ->limit($limit)
            ->get()
            ->toArray();
            if( empty($list) ) {
                break;
            }
            
            
            $endRow = end($list);
            $lastID = $endRow['ID'];
            $skuMap = array_column($list,null,'SKUCode');
            $skuCodes = array_keys($skuMap);
            $imgList = BdProduct::instance()
            ->select([
                'p.skuCode',
                'pimg.imgType',
                'pimg.imgUrl'
            ])
            ->from("Product as p")
            ->join("Product_img as pimg","p.productCode","=","pimg.productCode")
            ->whereIn("p.skuCode",$skuCodes)
            ->where('pimg.delStatus','N')
            ->orderBy('pimg.sequence','asc')
            ->get()
            ->toArray();
            
            $imgListMap = [];
            foreach ($imgList as $itemImg) 
            {
                $imgListMap[$itemImg['skuCode']][$itemImg['imgType']][] = $itemImg['imgUrl'];
            }
            
            foreach ($imgListMap as $skuCode => $newItem) 
            {
                //轮播图
                $bannerImgList = [];
                if( !empty($newItem[1]) ) {
                    foreach ($newItem[1] as $index => $img) 
                    {
                        $bannerImgList[] = [
                            'IsMain'    => $index == 0 ? 1 : 0,
                            'ImageUrl'  => $img
                        ];
                    }
                }
                
                //商品详情
                $html_desc = '';
                if( !empty($newItem[2]) ) {
                    foreach ($newItem[2] as $img)
                    {
                        $html_desc .= '<p><img src="'.$img.'" style="max-width:100%;" contenteditable="false"/></p>';
                    }
                }
                
                $sku_id = $skuMap[$skuCode]['ID'];
                echo $sku_id.PHP_EOL;
                $data = [
                    'UpdateTime'    => date("Y-m-d H:i:s"),
                    'Description'   => $html_desc,
                    'Images'        => json_encode($bannerImgList,JSON_UNESCAPED_UNICODE)
                ];
                CommodityDescription::instance()->where('CommodityInfoID',$sku_id)->update($data);
            }
        }
    }
    
    /**
     * 同步多件装数据
     */
    public function SyncBdNewClass()
    {
        $list = BdNewClass::instance()->orderBy('id','asc')->get()->toArray();
        foreach ($list as $item)
        {
            echo BdNewClass::instance()->where('id',$item['id'])->update([
                'new_id'    => IdService::instance()->getOtherID()
            ]).PHP_EOL;
        }
    }
    
    /**
     * 同步多件装数据
     */
    public function SyncBdRepeatSku()
    {
        $skucodes = $this->getRepeatGoodsSKu();
        foreach ($skucodes as $skucode) 
        {
            $info = CommodityArchives::instance()->info(['SKUcode'=>$skucode]);
            if( !empty($info) ) {
                continue;
            }
            
            //开始读取多件装的数据
            $sku = BdSku::instance()
            ->select([
                'upcName',
            ])
            ->where('skuCode',$skucode)
            ->first();
            
            if( empty($sku) ) 
            {
                continue;
            }
            
            $skuinfo = $sku->toArray();
            $skuSpecList = BdProductSku::instance()
            ->select([
                'pk.count as specNum',
                'p.costPrice',
                'p.productCode',
                'p.productImg',
                'p.mainCategory',
                'p.secondCategory',
                'p.upc',
                'p.spuId',
                'pk.sku as skuCode',
                'p.id',
                'p.markingPrice',
                'p.countryId',
                'p.unitId',
                'p.brandId',
                'p.attribute',
                'p.putAway',
                'p.delStatus',
            ])
            ->from("Product_sku as pk")
            ->join("Product as p","p.productCode",'=','pk.productCode')
            ->where('pk.sku',$skucode)
            ->get()
            ->toArray();
            
            if( empty($skuSpecList) ) {
                continue;
            }
            
            $goods = array_column($skuSpecList,null,'skuCode');
            $item  = $goods[$skucode];
            $insertBatch = [
                'ID'                     => IdService::instance()->getOtherID(),
                'BD_ID'                  => $item['id'],
                'MarketPrice'            => $item['markingPrice'],
                'SKUCode'                => $skucode,
                'SkuExtraCode'           => $item['productCode'],
                'CountryID'              => $item['countryId'],
                'UnitID'                 => $item['unitId'],
                'Name'                   => $skuinfo['upcName'],
                'BrandID'                => $item['brandId'],
                'FirstClassificationID'  => '834753927676612609',
                'SecondClassificationID' => $item['mainCategory'] ? $item['mainCategory'] : 0 ,
                'ThirdClassificationID'  => $item['secondCategory'] ? $item['secondCategory'] : 0 ,
                'SpuID'                  => $item['spuId'] ? $item['spuId'] : 0,
                'SpuSpecJsonBody'        => '',
                'BarCode'                => $item['upc'],
                'Weight'                 => '0.000',
                'CommodityType'          => $this->getGoodsType($item['attribute']),
                'IsForbidden'            => $item['putAway'] == 'UP' ? 0 : 1 ,
                'IsDeleted'              => $item['delStatus'] == 'Y' ? 1 : 0 ,
                'FreightTemplateID'      => 1,
                'IsIntegrity'            => 0,
                'IsUseAble'              => 0,
                'ThirdPartyCrmLinkTime'     => date('Y-m-d H:i:s'),
                'ThirdPartyCrmLinkStatus'   => 1,
                'ThirdPartyCrmContents'     => '默认绑定成功',
                'CreateTime'                => date('Y-m-d H:i:s')
            ];
            echo CommodityArchives::instance()->insert($insertBatch).PHP_EOL;
        }
    }
    
    /**
     * 同步供应商商品
     */
    public function syncSupplierCommodity() 
    {
        $supplierList = SupplierCompany::instance()->select(['ID','SupplierCode'])->where('ID','>=','859022557637283841')->orderBy('id','asc')->get()->toArray();
        $limit = 1000;
        foreach ($supplierList as $suplier) 
        {            
            //查询仓库            
            $wareHouse = WarehouseInfo::instance()->info(['SupplierID'=>$suplier['ID']]);
            if( empty($wareHouse) ) {
                continue;
            }
            
            print_r($wareHouse);
            $lastID = 0;
            while ( true )
            {
                $list = BdProduct::instance()
                ->where('depotCode',$wareHouse['WarehouseCode'])
                ->where('id','>',$lastID)
                ->orderBy('id','asc')
                ->limit($limit)
                ->get()
                ->toArray();
            
                if( empty($list) ) {
                    break;
                }
                
                $row = end($list);
                $lastID = $row['id'];
                
                echo $lastID.PHP_EOL;
                
                //批量查询skuid
                $productCodes   = array_column($list, null,'skuCode');
                $skuArrList     = CommodityArchives::instance()->select(['ID','SKUCode'])->whereIn('SkuCode',$productCodes)->get()->toArray();
                $skuArrListMap  = array_column($skuArrList, null,'SKUCode');
                
                //查询hascode
                $skuCodes     = array_column($list,'skuCode');
                $hsCodeSList  = BdSkuRecord::instance()->select(['skuCode','hsCode'])->whereIn('skuCode',$skuCodes)->get()->toArray();
                $hsCodeSListMap = array_column($skuArrList, null,'skuCode');
                
                
                //查询单位
                $units  = Unitinfo::instance()->whereIn('ExtraID',array_column($list,'unitId'))->get()->toArray();
                $unitsMap = array_column($units, null,'ID');
                
                //查询品牌
                $brands  = Brandinfo::instance()->whereIn('ExtraID',array_column($list,'brandId'))->get()->toArray();
                $brandsMap = array_column($brands, null,'ID');
                
                //查询分类
                $class  = Classifyinfo::instance()->whereIn('ExtraID',array_column($list,'secondCategory'))->get()->toArray();
                $classMap = array_column($class, null,'ID');
                
                //查询产地
                $country  = Countryinfo::instance()->whereIn('ExtraID',array_column($list,'countryId'))->get()->toArray();
                $countryMap = array_column($country, null,'ID');
                
                $insertBatch = [];
                foreach ($list as $item)
                {
                    $productCode = $item['skuCode'];
                    if( empty($item['wmsSkuCode']) ) {
                        continue;
                    }
                    
                    $skuCode     = $item['skuCode'];
                    $sku_id      = !empty($skuArrListMap[$productCode]) ? $skuArrListMap[$productCode]['ID'] : 0;
                    $HSCode      = !empty($hsCodeSListMap[$skuCode]) ? $hsCodeSListMap[$skuCode]['hsCode'] : '';
                    $insertBatch[] = [
                        'CreateTime'                            => date("Y-m-d H:i:s"),
                        'ID'                                    => IdService::instance()->getOtherID(),
                        'TaxRate'                               => $item['taxRate'] ? $item['taxRate'] : '0.000' ,
                        'SupplierCommodityDescription'          => '<img src="'.$item['productImg'].'" alt="" />',
                        'SupplierCommodityUinit'                => $unitsMap[$item['unitId']] ?? '',
                        'SupplierCommodityBrand'                => !empty($brandsMap[$item['brandId']]) ? $brandsMap[$item['brandId']] : '',
                        'SupplierCommodityClassify'             => $classMap[$item['secondCategory']] ?? '',
                        'SupplierCommodityOriginPlace'          => $countryMap[$item['brandId']] ?? '',
                        'SupplierCommodityInternationBarCode'   => $item['upc'],
                        'SupplierCommodityType'                 => $this->getGoodsType($item['attribute']),
                        'SupplierCommodityImageUrl'             => json_encode([$item['productImg']],JSON_UNESCAPED_UNICODE),
                        'SupplierCompanyID'                     => $suplier['ID'],
                        'SupplierCommoditySkuCode'              => $item['wmsSkuCode'],
                        'SupplierCommodityName'                 => $item['productName'],
                        'SupplierCommodityKey'                  => $item['wmsSkuCode'],
                        'SupplierCommodityNetWeight'            => '0.000',
                        'SaleType'                              => $item['putAway'] == 'UP' ? 1 : 0,
                        'SKUCode'                               => $skuCode,
                        'CommodityArchivesID'                   => $sku_id,
                        'HSCode'                                => $HSCode,
                        'IsHaveTaxRate'                         => $item['freeTax'] == 'Y' ? 1 : 0,
                        'UpstreamSaleType'                      => $item['putAway'] == 'UP' ? 1 : 0,
                        'IsFreeShipping'                        => 0,
                    ];
                }
                
                echo "开始写入数据".count($insertBatch).PHP_EOL;
                if( !empty($insertBatch) ) {
                    SupplierCommodity::instance()->insert($insertBatch);
                }
            }
        }
    }
    
    /**
     * 同步百大供应商商品库存和价格
     */
    public function startSyncCommodityStockAndPriceNew()
    {
        $limit = 1000;
        $lastID = 0;
        while ( true )
        {
            $list = SupplierCommodity::instance()
            ->from('suppliercommodity_s2b as scb')
            ->join('commodityarchives_s2b as csb','csb.ID','=','scb.CommodityArchivesID')
            ->select([
                'scb.ID',
                'scb.SKUCode',
                'scb.CommodityArchivesID',
                'scb.SupplierCompanyID',
            ])
            ->where('csb.ID','>','859534574597029889')
            ->where('scb.ID','>',$lastID)
            ->orderBy('csb.ID','asc')
            ->limit($limit)
            ->get()
            ->toArray();
    
            if( empty($list) ) {
                break;
            }
    
            $row = end($list);
            $lastID = $row['ID'];
            echo $lastID.PHP_EOL;
            
            $insertBatch = [];
            foreach ($list as $goods)
            {
                $skuSpecList = BdProductSku::instance()
                ->select([
                    'pk.count as specNum',
                    'p.costPrice',
                    'pk.sku as skuCode',
                ])
                ->from("Product_sku as pk")
                ->join("Product as p","p.productCode",'=','pk.productCode')
                ->where('pk.sku',$goods['SKUCode'])
                ->orderBy('pk.count','asc')
                ->get()
                ->toArray();
                
                $BD_SKU_CODE = $goods['SKUCode'];
                $SpecList = [];
                $priceArr = [];
                foreach ($skuSpecList as $item) 
                {
                    $SpecList[] = [
                        'SpecificationNum'            => (string)$item['specNum'],
                        'SpecificationPrice'          => (string)$item['costPrice'],
                        'SpecificationFreightPrice'   => (string)$item['costPrice'],
                    ];
                    $priceArr[] = bcdiv((string)$item['costPrice'],(string)$item['specNum'],2);
                }
                
                $BatchSpecMinSinglePrice = min($priceArr);
                $BatchSpecMaxSinglePrice = max($priceArr);
                
                //获取最新的库存方式
                $bdStockInfos       = BdSkuStock::instance()->select(['skuCode','availableStock'])->whereIn('skuCode',[$BD_SKU_CODE])->get()->toArray();
                $bdStockInfosMap    = array_column($bdStockInfos,null,'skuCode');
                $Number             = !empty($bdStockInfosMap[$BD_SKU_CODE]) ? $bdStockInfosMap[$BD_SKU_CODE]['availableStock'] : 0;
                
                //库存
                $insertBatch = [
                    'UpdateTime'                            => date("Y-m-d H:i:s"),
                    'IsDeleted'                             => 0,
                    'Number'                                => $Number,
                    'BatchNo'                               => '基准批次',
                    'BatchSpecMinSinglePrice'               => $BatchSpecMinSinglePrice,
                    'BatchSpecMaxSinglePrice'               => $BatchSpecMaxSinglePrice,
                    'IsHasPrice'                            => !empty($SpecList) ? 1 : 0 ,
                    'SpecList'                              => json_encode($SpecList,JSON_UNESCAPED_UNICODE),
                    'SupplierCompanyID'                     => $goods['SupplierCompanyID'],
                    'CommodityArchivesID'                   => $goods['CommodityArchivesID'],
                    'SupplierCommodityID'                   => $goods['ID'],
                ];
                
                echo Stockinfo::instance()->where('SupplierCommodityID',$goods['ID'])->update($insertBatch);
            }
        }
    }
    
    /**
     * 同步百大供应商商品库存和价格
     */
    public function startSyncCommodityStockAndPrice()
    {
        $limit = 1000;
        $lastID = 0;
        while ( true )
        {
            $list = SupplierCommodity::instance()
            ->from('suppliercommodity_s2b as scb')
            ->select([
                'scb.ID',
                'scb.SKUCode',
                'scb.CommodityArchivesID',
                'scb.SupplierCompanyID',
                'wh.ID AS warehouse_id'
            ])
            ->join('warehouseinfo_s2b as wh','wh.SupplierID','=','scb.SupplierCompanyID')
            ->where('scb.ID','>','859534574597029889')
            ->where('scb.ID','>',$lastID)
            ->orderBy('scb.ID','asc')
            ->limit($limit)
            ->get()
            ->toArray();
            
            if( empty($list) ) {
                break;
            }
        
            $row = end($list);
            $lastID = $row['ID'];
            echo $lastID.PHP_EOL;
            
            //获取仓库真实数据
            $bd_sku_list = array_column($list, null,'SKUCode');
            $BD_SKU_CODES = array_keys($bd_sku_list);

            //获取最新的库存方式
            $bdStockInfos       = BdSkuStock::instance()->select(['skuCode','availableStock'])->whereIn('skuCode',$BD_SKU_CODES)->get()->toArray();
            $bdStockInfosMap    = array_column($bdStockInfos,null,'skuCode');
            
            //获取价格
            $priceList          = BdSku::instance()->select(['costPrice','number','skuCode'])->whereIn('skuCode',$BD_SKU_CODES)->get()->toArray();
            $priceListMap       = array_column($priceList,null,'skuCode');
            
            $insertBatch = [];
            foreach ($list as $goods)
            {
                $BD_SKU_CODE = $goods['SKUCode'];
                $SpecList = [];
                $BatchSpecMinSinglePrice = $BatchSpecMaxSinglePrice = '0.00';
                if( !empty($priceListMap[$BD_SKU_CODE]) )
                {
                    $spec = $priceListMap[$BD_SKU_CODE];
                    $SpecList = [
                        [
                            'SpecificationNum'            => (string)$spec['number'],
                            'SpecificationPrice'          => (string)$spec['costPrice'],
                            'SpecificationFreightPrice'   => (string)$spec['costPrice'],
                        ]
                    ];
                    $BatchSpecMinSinglePrice = $BatchSpecMaxSinglePrice = (string)$spec['costPrice'];
                }
                
                $Number = 0;
                if( !empty($bdStockInfosMap[$BD_SKU_CODE]) )
                {
                    $Number = $bdStockInfosMap[$BD_SKU_CODE]['availableStock'];
                }
                
                //库存
                $insertBatch[] = [
                    'CreateTime'                            => date("Y-m-d H:i:s"),
                    'IsDeleted'                             => 0,
                    'ID'                                    => IdService::instance()->getOtherID(),
                    'Number'                                => $Number,
                    'BatchNo'                               => '基准批次',
                    'BatchSpecMinSinglePrice'               => $BatchSpecMinSinglePrice,
                    'BatchSpecMaxSinglePrice'               => $BatchSpecMaxSinglePrice,
                    'IsHasPrice'                            => !empty($SpecList) ? 1 : 0 ,
                    'SpecList'                              => json_encode($SpecList,JSON_UNESCAPED_UNICODE),
                    'SupplierCompanyID'                     => $goods['SupplierCompanyID'],
                    'CommodityArchivesID'                   => $goods['CommodityArchivesID'],
                    'SupplierCommodityID'                   => $goods['ID'],
                    'WarehouseID'                           => $goods['warehouse_id'],
                ];
            }
            
            if( $insertBatch ) {
                Stockinfo::instance()->insert($insertBatch);
            }
        }
    }
    
    /**
     * 同步百大供应商和仓库
     */
    public function startSyncSupplierAndWareHouse()
    {
        $page = 0;
        $limit = 10;
        
        while ( true ) 
        {
            $pageOffset = $page * $limit;
            $list = BdSupplier::instance()
            ->orderBy('supplierCode','asc')
            ->offset($pageOffset)
            ->limit($limit)
            ->get()
            ->toArray();
            
            if( empty($list) ) 
            {
                break;
            }
            
            foreach ($list as $item) 
            {
                $this->syncSupplierAndWareHouse($item);
            }
            
            $page ++;
        }
    }
    
    /**
     * 同步供应商和仓库数据
     * @param array $data
     */
    public function syncSupplierAndWareHouse(array $data)
    {
        $supplierCode = $data['supplierCode'];
        echo $supplierCode.PHP_EOL;
        $info = SupplierCompany::instance()->info(['SupplierCode'=>$supplierCode]);
        //判断是否申报
        $bDWareHouse = BdWareHouse::instance()->info(['SupplierCode'=>$supplierCode]);
        if( empty($info) ) 
        {
            $supplier_id = IdService::instance()->getOtherID();
            if( !empty($bDWareHouse['attribute']) && in_array($bDWareHouse['attribute'],['5','6','7']) ) 
            {
                $PayDeclare = 1;
            } else {
                $PayDeclare = 0;
            }
            $supplier_data = [
                'ID'                    => $supplier_id,
                'SupplierName'          => $data['supplierName'],
                'SupplierCode'          => $supplierCode,
                'CompanyStatus'         => 1,
                'SettlementMethod'      => 1,
                'OrderDeclare'          => 0,
                'PayDeclare'            => $PayDeclare,
                'OrderDockMode'         => 1,
                'IsOpenSupplierSettleIn'=> 0,
                'ShowInPreferred'       => 1,
                'SupplierAlias'         => $data['supplierName'],
                'CreateTime'            => date('Y-m-d H:i:s'),
                'IsDeleted'             => 0
            ];
            SupplierCompany::instance()->add($supplier_data);
        } else {
            $supplier_id = $info['ID'];
        }
        
        //写入仓库
        $wh = WarehouseInfo::instance()->info(['SupplierID'=>$supplier_id]);
        if( empty($wh) && !empty($bDWareHouse) ) 
        {
            $wh_id = IdService::instance()->getOtherID();
            $wh_data = [
                'ID'                    => $wh_id,
                'WarehouseAccount'      => $supplierCode,
                'WarehouseType'         => 0,
                'ExamineState'          => 1,
                'SupplierID'            => $supplier_id,
                'WarehouseCode'         => $bDWareHouse['depotCode'],
                'WarehouseName'         => $bDWareHouse['depotName'],
                'CanModifyStock'        => 1,
                'CanModifyPrice'        => 1,
                'IsCombineOrders'       => 1,
                'CreateTime'            => date('Y-m-d H:i:s'),
                'IsDeleted'             => 0,
                'JsonBody'              => json_encode([]),
            ];
            WarehouseInfo::instance()->add($wh_data);
        }
    }
    
    /**
     * 同步漏掉的仓库
     */
    public function syncNewWareHouse() 
    {
        $wareHouseList = WarehouseInfo::instance()->select(['WarehouseCode'])->get()->toArray();
        $WarehouseCodes = array_column($wareHouseList,'WarehouseCode');
        $newWareHouseList = BdWareHouse::instance()->whereNotIn('depotCode',$WarehouseCodes)->get()->toArray();
        if( empty($newWareHouseList) ) {
            return;
        }
        
        foreach ($newWareHouseList as $item) 
        {
            $leve_up_supplier = BdSupplier::instance()->info(['supplierCode'=>$item['supplierCode']]);
            
            $supplierCode = $item['supplierCode'].'-'.$item['depotCode'];
            $supplier_id = IdService::instance()->getOtherID();
            if( !empty($item['attribute']) && in_array($item['attribute'],['5','6','7']) )
            {
                $PayDeclare = 1;
            } else {
                $PayDeclare = 0;
            }
            
            $supplier_data = [
                'ID'                    => $supplier_id,
                'SupplierName'          => empty($leve_up_supplier['supplierName']) ? $item['depotName'] : $leve_up_supplier['supplierName']."（{$item['depotName']}）",
                'SupplierCode'          => $supplierCode,
                'CompanyStatus'         => 1,
                'SettlementMethod'      => 1,
                'OrderDeclare'          => 0,
                'PayDeclare'            => $PayDeclare,
                'OrderDockMode'         => 1,
                'IsOpenSupplierSettleIn'=> 0,
                'ShowInPreferred'       => 1,
                'SupplierAlias'         => $item['depotName'],
                'CreateTime'            => date('Y-m-d H:i:s'),
                'IsDeleted'             => 0
            ];
            $info = SupplierCompany::instance()->info(['SupplierCode'=>$supplierCode]);
            if( empty($info) ) {
                SupplierCompany::instance()->add($supplier_data);
            } else {
                $supplier_id = $supplier_id = $info['ID'];
            }
            
            //写入仓库
            $wh = WarehouseInfo::instance()->info(['SupplierID'=>$supplier_id]);
            if( empty($wh) )
            {
                $wh_id = IdService::instance()->getOtherID();
                $wh_data = [
                    'ID'                    => $wh_id,
                    'WarehouseAccount'      => $supplierCode,
                    'WarehouseType'         => 0,
                    'ExamineState'          => 1,
                    'SupplierID'            => $supplier_id,
                    'WarehouseCode'         => $item['depotCode'],
                    'WarehouseName'         => $item['depotName'],
                    'CanModifyStock'        => 1,
                    'CanModifyPrice'        => 1,
                    'IsCombineOrders'       => 1,
                    'CreateTime'            => date('Y-m-d H:i:s'),
                    'IsDeleted'             => 0,
                    'JsonBody'              => json_encode([]),
                ];
                WarehouseInfo::instance()->add($wh_data);
            }
        }
    }
    
    /**
     * 同步品牌
     */
    public function syncBdBrand()
    {
        $page = 0;
        $limit = 10;
        while ( true )
        {
            $pageOffset = $page * $limit;
            $list = BdBrand::instance()
            ->orderBy('brandId','asc')
            ->offset($pageOffset)
            ->limit($limit)
            ->get()
            ->toArray();
        
            if( empty($list) )
            {
                break;
            }
            
            foreach ($list as $item)
            {
                $brandInfo = Brandinfo::instance()->info(['BrandName'=>$item['brandNameCn']]);
                if( empty($brandInfo) ) 
                {
                    echo $item['brandId'].PHP_EOL;
                    $data = [
                        'ID'                => IdService::instance()->getOtherID(),
                        'BD_ID'             => $item['brandId'],
                        'IsDeleted'         => 0,
                        'CreateTime'        => date('Y-m-d H:i:s'),
                        'OrderInt'          => 0,
                        'BrandCode'         => $item['brandId'],
                        'Abbreviation'      => $item['brandNameEn'],
                        'BrandName'         => $item['brandNameCn'],
                        'BrandFirstLetter'  => strtoupper(mb_substr($item['brandNameEn'],0,1)),
                        'Image'             => $item['logo'],
                        'Banner'            => $item['logo'],
                        'IsShow'            => 1,
                    ];
                    Brandinfo::instance()->add($data);
                }
            }
        
            $page ++;
        }
    }
    
    /**
     * 同步分类
     */
    public function syncBdClass()
    {
        $page = 0;
        $limit = 10;
        while ( true )
        {
            $pageOffset = $page * $limit;
            $list = BdClass::instance()
            ->orderBy('cid','asc')
            ->offset($pageOffset)
            ->limit($limit)
            ->get()
            ->toArray();
    
            if( empty($list) )
            {
                break;
            }
    
            foreach ($list as $item)
            {
                $classInfo = Classifyinfo::instance()->info(['ClassificationName'=>$item['categoryName']]);
                if( empty($classInfo) )
                {
                    echo $item['categoryName'].PHP_EOL;
                    $data = [
                        'ID'                    => IdService::instance()->getOtherID(),
                        'BD_ID'                 => $item['cid'],
                        'IsDeleted'             => 0,
                        'CreateTime'            => date('Y-m-d H:i:s'),
                        'TaxRate'               => '0.000',
                        'Level'                 => $item['parentId'] > 0 ? 3 : 2,
                        'IsForbidden'           => 0,
                        'ClassificationCode'    => $item['crmCategory'],
                        'ParentID'              => $item['parentId'],
                        'ClassificationName'    => $item['categoryName'],
                        'Image'                 => $item['categoryLogo'],
                        'IsNotShow'             => 0,
                    ];
                    Classifyinfo::instance()->add($data);
                }
            }
            $page ++;
        }
    }
    
    /**
     * 同步产地国家
     */
    public function syncBdCountry()
    {
        $page = 0;
        $limit = 10;
        while ( true )
        {
            $pageOffset = $page * $limit;
            $list = BdCountry::instance()
            ->orderBy('countryId','asc')
            ->offset($pageOffset)
            ->limit($limit)
            ->get()
            ->toArray();
    
            if( empty($list) )
            {
                break;
            }
            
            foreach ($list as $item)
            {
                $countryInfo = Countryinfo::instance()->info(['CountryName'=>$item['countryName']]);
                if( empty($countryInfo) )
                {
                    echo $item['countryName'].PHP_EOL;
                    $data = [
                        'ID'                    => IdService::instance()->getOtherID(),
                        'BD_ID'                 => $item['countryId'],
                        'IsDeleted'             => 0,
                        'CreateUserID'          => 0,
                        'CreateTime'            => date('Y-m-d H:i:s'),
                        'OrderInt'              => 0,
                        'CountryCode'           => $item['code'],
                        'CountryAbbreviation'   => $item['countryNameEn'],
                        'CountryName'           => $item['countryName'],
                        'Image'                 => '',
                        'IsShow'                => 1,
                    ];
                    Countryinfo::instance()->add($data);
                }
            }
            $page ++;
        }
    }
    
    /**
     * 同步spu
     */
    public function syncBdSpu()
    {
        $page = 0;
        $limit = 1000;
        while ( true )
        {
            $pageOffset = $page * $limit;
            $list = BdSpu::instance()
            ->orderBy('spuId','asc')
            ->offset($pageOffset)
            ->limit($limit)
            ->get()
            ->toArray();
    
            if( empty($list) )
            {
                break;
            }
    
            $spuNameRows = array_column($list,null,'spuName');
            $spuNameArr = array_keys($spuNameRows);
            $spuList = CommoditySpu::instance()->whereIn('SpuName',$spuNameArr)->get()->toArray();
            if( !empty($spuList) ) {
                foreach ($spuList as $spu) {
                    unset($spuNameRows[$spu['SpuName']]);
                }
            }
            
            if( !empty($spuNameRows) ) 
            {
                $insertBatch = [];
                foreach ($spuNameRows as $item)
                {
                    $temp = [
                        'ID'                    => IdService::instance()->getOtherID(),
                        'BD_ID'                 => $item['spuId'],
                        'IsDeleted'             => 0,
                        'CreateTime'            => date('Y-m-d H:i:s'),
                        'SpuCode'               => 'SP'.IdService::instance()->getOtherID(),
                        'SpuName'               => addslashes($item['spuName']),
                    ];
                    $insertBatch[] = "('" . \implode("','", $temp) . "')"; 
                }
                
                $value_sql =  \implode(",", $insertBatch);
                
                //批量更新数据
                $connectName    = CommoditySpu::instance()->getConnectionName();
                $databaseName   = CommoditySpu::instance()->getConnection()->getDatabaseName();
                $tableName      = CommoditySpu::instance()->getTable();
                $sql_batch_sql  = "INSERT IGNORE INTO `{$tableName}` (ID,BD_ID,IsDeleted,CreateTime,SpuCode,SpuName) values {$value_sql}";
                Db::connection($connectName)->update($sql_batch_sql);
            }
            
            echo $page.PHP_EOL;
            $page ++;
        }
    }
    
    /**
     * 同步商品sku
     */
    public function syncBdGoodsSku()
    {
        $page = 0;
        $limit = 2000;
        $lastId = 0;
        while ( true )
        {
            $list = BdProduct::instance()
            ->select([
                'id',
                'markingPrice',
                'productCode',
                'countryId',
                'unitId',
                'productName',
                'brandId',
                'mainCategory',
                'secondCategory',
                'spuId',
                'upc',
                'attribute',
                'putAway',
                'delStatus'
            ])
            ->orderBy('id','asc')
            ->where('id','>',$lastId)
            ->limit($limit)
            ->get()
            ->toArray();
    
            if( empty($list) ) {
                break;
            }
            
            $endRow = end($list);
            $lastId = $endRow['id'];
            $skuRows = array_column($list,null,'productCode');
            $skuArr = array_keys($skuRows);
            $skuList = CommodityArchives::instance()->whereIn('SKUCode',$skuArr)->get()->toArray();
            if( !empty($skuList) ) {
                foreach ($skuList as $sku) {
                    unset($skuRows[$sku['SKUCode']]);
                }
            }
            
            if( !empty($skuRows) )
            {
                $insertBatch = [];
                foreach ($skuRows as $item)
                {
                    $insertBatch[] = [
                        'ID'                     => IdService::instance()->getOtherID(),
                        'BD_ID'                  => $item['id'],
                        'MarketPrice'            => $item['markingPrice'],
                        'SKUCode'                => $item['productCode'],
                        'CountryID'              => $item['countryId'],
                        'UnitID'                 => $item['unitId'],
                        'Name'                   => $item['productName'],
                        'BrandID'                => $item['brandId'],
                        'FirstClassificationID'  => '834753927676612609',
                        'SecondClassificationID' => $item['mainCategory'] ? $item['mainCategory'] : 0 ,
                        'ThirdClassificationID'  => $item['secondCategory'] ? $item['secondCategory'] : 0 ,
                        'SpuID'                  => $item['spuId'] ? $item['spuId'] : 0,
                        'SpuSpecJsonBody'        => '',
                        'BarCode'                => $item['upc'],
                        'Weight'                 => '0.000',
                        'CommodityType'          => $this->getGoodsType($item['attribute']),
                        'IsForbidden'            => $item['putAway'] == 'UP' ? 0 : 1 ,
                        'IsDeleted'              => $item['delStatus'] == 'Y' ? 1 : 0 ,
                        'FreightTemplateID'      => 1,
                        'IsIntegrity'            => 0,
                        'IsUseAble'              => 0,
                        'ThirdPartyCrmLinkTime'     => date('Y-m-d H:i:s'),
                        'ThirdPartyCrmLinkStatus'   => 1,
                        'ThirdPartyCrmContents'     => '默认绑定成功',
                        'CreateTime'                => date('Y-m-d H:i:s')
                    ];
                }
                CommodityArchives::instance()->insert($insertBatch);
            }
            
            echo $page.PHP_EOL;
            $page++;
        }
    }
    
    /**
     * 获取商品类型
     * @param $goodsType
     */
    public function getGoodsType( $goodsType )
    {
        if( in_array($goodsType,['1','5']) ) {
            return 1;
        } else if( in_array($goodsType,['2','6']) ) {
            return 0;
        } else if( in_array($goodsType,['3','4','7']) ) {
            return 2;
        } else {
            return 0;
        }
    }
    
    /**
     * 同步商品sku详情
     */
    public function syncBdGoodsSkuDesc()
    {
        $page = 0;
        $limit = 1000;
        $lastId = 0;
        while ( true )
        {
            $list = CommodityArchives::instance()
            ->select([
                'ID',
                'SKUCode'
            ])
            ->orderBy('ID','asc')
            ->where('ID','>=','859534574597029889')
            ->where('ID','>',$lastId)
            ->limit($limit)
            ->get()
            ->toArray();
            
            if( empty($list) ) {
                break;
            }
            
            
            foreach ($list as $item) 
            {
                $images = BdProductSku::instance()
                ->select([
                    'pi.imgUrl',
                    'pi.imgType'
                ])
                ->from("Product_sku as ks")
                ->join("Product_img as pi","ks.productCode",'=','pi.productCode')
                ->where('pi.delStatus','N')
                ->where('ks.sku',$item['SKUCode'])
                ->get()
                ->toArray();
                
                $newImgs = [];
                foreach ($images as $desc)
                {
                    $newImgs[] = [
                        'IsMain'    => $desc['imgType'] == 1 ? 1 : 0,
                        'ImageUrl'  => $desc['imgUrl']
                    ];
                    unset($desc);
                }
                
                
                $imageNew = [];
                $hasMain = 0;
                $html = '';
                foreach ($newImgs as $img)
                {
                    if( $hasMain == 1 ) {
                        $img['IsMain'] = 0;
                    } else {
                        $hasMain = $img['IsMain'];
                    }
                    
                    $imageNew[] = $img;
                    $html .= '<p><img src="'.$img['ImageUrl'].'" style="max-width:100%;" contenteditable="false"/></p>';
                }
                
                $insertBatch = [
                    'ID'                     => IdService::instance()->getOtherID(),
                    'Description'            => $html,
                    'HasDes'                 => 1,
                    'CommodityInfoID'        => $item['ID'],
                    'Images'                 => json_encode($imageNew,JSON_UNESCAPED_UNICODE),
                    'HasImage'               => 1,
                    'CreateTime'             => date('Y-m-d H:i:s')
                ];
                echo CommodityDescription::instance()->insert($insertBatch);
            }
            
            
            $endRow = end($list);
            $lastId = $endRow['ID'];
            /* $skudescRows = array_column($list,null,'SKUCode');
            $skuIDSkuCodeMap = array_column($list,'SKUCode','ID');
            $skudescArr = array_keys($skudescRows);
            $skudescList = BdProductImage::instance()->select(['imgUrl','productCode','imgType'])->whereIn('productCode',$skudescArr)->where('delStatus','N')->get()->toArray();
            $skudescListMap = [];
            foreach ($skudescList as $desc)
            {
                $skudescListMap[$desc['productCode']][] = [
                    'IsMain'    => $desc['imgType'] == 1 ? 1 : 0,
                    'ImageUrl'  => $desc['imgUrl']
                ];
                unset($desc);
            }
            
            $skuRows = array_column($list,null,'ID');
            $skuArr = array_keys($skuRows);
            $skuList = CommodityDescription::instance()->whereIn('CommodityInfoID',$skuArr)->get()->toArray();
            if( !empty($skuList) ) {
                foreach ($skuList as $sku) 
                {
                    unset($skuIDSkuCodeMap[$sku['CommodityInfoID']]);
                }
            }
            
            if( !empty($skuRows) )
            {
                $insertBatch = [];
                foreach ($skuIDSkuCodeMap as $sku_id => $skuCode)
                {
                    if( !empty($skudescListMap[$skuCode]) ) 
                    {
                        $images = $skudescListMap[$skuCode];
                        $imageNew = [];
                        $hasMain = 0;
                        $html = '';
                        foreach ($images as $img) {
                            if( $hasMain == 1 ) {
                                $img['IsMain'] = 0;
                            } else {
                                $hasMain = $img['IsMain'];
                            }
                            
                            $imageNew[] = $img;
                            $html .= '<p><img src="'.$img['ImageUrl'].'" style="max-width:100%;" contenteditable="false"/></p>';
                        }
                        
                        $insertBatch[] = [
                            'ID'                     => IdService::instance()->getOtherID(),
                            'Description'            => $html,
                            'HasDes'                 => 1,
                            'CommodityInfoID'        => $sku_id,
                            'Images'                 => json_encode($imageNew,JSON_UNESCAPED_UNICODE),
                            'HasImage'               => 1,
                            'CreateTime'             => date('Y-m-d H:i:s')
                        ];
                    }
                }
                
                if( !empty($insertBatch) ) {
                    CommodityDescription::instance()->insert($insertBatch);                    
                }
            } */
            
            echo $page.PHP_EOL;
            $page++;
        }
    }
    
    /**
     * 同步商品规格属性
     */
    public function syncBdGoodsSkuAttr()
    {
        $page = 0;
        $limit = 2000;
        $lastId = 0;
        while ( true )
        {
            $list = BdAttr::instance()
            ->select([
                'attrId',
                'attrName',
                'spuId'
            ])
            ->orderBy('attrId','asc')
            ->where('attrId','>',$lastId)
            ->limit($limit)
            ->get()
            ->toArray();
    
            if( empty($list) ) {
                break;
            }
            
            $endRow = end($list);
            $lastId = $endRow['attrId'];
            
            $insertBatch = [];
            foreach ($list as $item)
            {
                $temp = [
                    'ID'                    => IdService::instance()->getOtherID(),
                    'BD_ID'                 => $item['attrId'],
                    'BD_SPU_ID'             => $item['spuId'],
                    'IsDeleted'             => 0,
                    'CreateTime'            => date('Y-m-d H:i:s'),
                    'AttrName'              => addslashes($item['attrName']),
                ];
                $insertBatch[] = $temp;
            }
            
            CommoditySpecAttr::instance()->insert($insertBatch);
            echo $page.PHP_EOL;
            $page++;
        }
    }
    
    /**
     * 同步商品规格属性值
     */
    public function syncBdGoodsSkuAttrValue()
    {
        $page = 0;
        $limit = 2000;
        $lastId = 0;
        while ( true )
        {
            $list = BdAttrValue::instance()
            ->select([
                'attrValueId',
                'attrValueName',
                'attrId'
            ])
            ->orderBy('attrValueId','asc')
            ->where('attrValueId','>',$lastId)
            ->limit($limit)
            ->get()
            ->toArray();
            
            if( empty($list) ) {
                break;
            }
            
            $endRow = end($list);
            $lastId = $endRow['attrValueId'];
            
            $data = [];
            foreach ($list as $item)
            {
                $data[] = [
                    'ID'                => IdService::instance()->getOtherID(),
                    'BD_ID'             => $item['attrValueId'],
                    'IsDeleted'         => 0,
                    'CreateTime'        => date('Y-m-d H:i:s'),
                    'SpecID'            => $item['attrId'],
                    'ValueName'         => $item['attrValueName'],
                ];
            }
            
            CommoditySpecValue::instance()->insert($data);
            echo $page.PHP_EOL;
            $page++;
        }
    }
    
    /**
     * 同步商品规格属性组
     */
    public function syncBdGoodsSkuAttrGroup()
    {
        $limit = 1000;
        $lastId = 0;
        while ( true )
        {
            $list = BdSpu::instance()
            ->select([
                'spuId',
                'spuName',
            ])
            ->orderBy('spuId','asc')
            ->where('spuId','>',$lastId)
            ->limit($limit)
            ->get()
            ->toArray();
            
            if( empty($list) ) {
                break;
            }
            
            $row = end($list);
            $lastId = $row['spuId'];
            
            ECHO $lastId.PHP_EOL;
            $spuRows = array_column($list,null,'spuId');
            $spuIds  = array_keys($spuRows);
            $attrGroupRows = BdAttr::instance()->select([
                'spuId',
                Db::raw('GROUP_CONCAT(attrName SEPARATOR "-") AS attr_group_name')
            ])
            ->whereIn('spuId',$spuIds)
            ->groupBy('spuId')
            ->get()
            ->toArray();
            
            if( !empty($attrGroupRows) )
            {
                $insertBatch = [];
                foreach ($attrGroupRows as $item)
                {
                    $spuId = $item['spuId'];
                    $attr_group_name = $item['attr_group_name'] . "（{$spuRows[$spuId]['spuName']}）";
                    echo $attr_group_name.PHP_EOL;
                    $temp = [
                        'ID'            => IdService::instance()->getOtherID(),
                        'BD_SPU_ID'     => $spuId,
                        'IsDeleted'     => 0,
                        'CreateTime'    => date('Y-m-d H:i:s'),
                        'GroupName'     => addslashes($attr_group_name),
                    ];
                    $insertBatch[] = "('" . \implode("','", $temp) . "')";
                }
            
                $value_sql =  \implode(",", $insertBatch);
                //批量更新数据
                $connectName    = CommoditySpecGroup::instance()->getConnectionName();
                $databaseName   = CommoditySpecGroup::instance()->getConnection()->getDatabaseName();
                $tableName      = CommoditySpecGroup::instance()->getTable();
                $sql_batch_sql  = "INSERT IGNORE INTO `{$tableName}` (ID,BD_SPU_ID,IsDeleted,CreateTime,GroupName) values {$value_sql}";
                Db::connection($connectName)->update($sql_batch_sql);
            }
        }
    }
    
    /**
     * 同步处理商品属性组关联关系表
     */
    public function syncBdSpuAttrGroup()
    {
        $limit = 2000;
        $lastId = 0;
        while ( true )
        {
            $list = CommoditySpecGroup::instance()
            ->from('commodity_spec_group as csg')
            ->select([
                Db::raw("csg.ID as GroupID"),
                Db::raw("csa.ID as AttrID"),
            ])
            ->join('commodity_spec_attr as csa','csa.BD_SPU_ID','=','csg.BD_SPU_ID')
            ->orderBy('csa.ID','asc')
            ->where('csa.ID','>',$lastId)
            ->where('csg.SpuID','>',0)
            ->where('csg.ClassID','>',0)
            ->limit($limit)
            ->get()
            ->toArray();
            
            if( empty($list) ) {
                break;
            }
        
            $row = end($list);
            $lastId = $row['AttrID'];
            echo $lastId.PHP_EOL;
            if( !empty($list) )
            {
                $insertBatch = [];
                foreach ($list as $item)
                {
                    $temp = [
                        'ID'            => IdService::instance()->getOtherID(),
                        'IsDeleted'     => 0,
                        'CreateTime'    => date('Y-m-d H:i:s'),
                        'GroupID'       => $item['GroupID'],
                        'AttrID'        => $item['AttrID'],
                    ];
                    $insertBatch[] = "('" . \implode("','", $temp) . "')";
                }
                
                $value_sql =  \implode(",", $insertBatch);
                //批量更新数据
                $connectName    = CommodityGroupAttr::instance()->getConnectionName();
                $databaseName   = CommodityGroupAttr::instance()->getConnection()->getDatabaseName();
                $tableName      = CommodityGroupAttr::instance()->getTable();
                $sql_batch_sql  = "INSERT IGNORE INTO `{$tableName}` (ID,IsDeleted,CreateTime,GroupID,AttrID) values {$value_sql}";
                Db::connection($connectName)->update($sql_batch_sql);
            }
        }
    }
    
    /**
     * 同步商品单位
     */
    public function syncBdGoodsUnit()
    {
        $list = BdUnit::instance()->get()->toArray();
        foreach ($list as $item)
        {
            $info = Unitinfo::instance()->where('Name',$item['unitName'])->first();
            if( empty($info) ) {
                $data = [
                    'ID'                => IdService::instance()->getOtherID(),
                    'BD_ID'             => $item['unitId'],
                    'IsDeleted'         => 0,
                    'CreateUserID'      => 0,
                    'CreateTime'        => date('Y-m-d H:i:s'),
                    'Name'              => $item['unitName'],
                    'UnitCode'          => $item['unitCode'],
                ];
                Unitinfo::instance()->add($data);
            }
        }
    }
    
    public function getRepeatGoodsSKu()
    {
        return [
            'KGB000984',
            'KGB000971',
            'KGBD012748',
            'KGBD001964',
            'KGBD001965',
            'KGBD000792',
            'KGB001775',
            'KGB001776',
            'KGB001777',
            'KGBD012154',
            'KGBD012155',
            'KGBD000330',
            'KGBD000331',
            'KGBD000332',
            'KGBD000333',
            'KGBD000334',
            'KGBD000335',
            'KGBD000336',
            'KGBD000337',
            'KGBD000338',
            'KGB000857',
            'KGB000856',
            'KGB000855',
            'KGB000862',
            'KGB000861',
            'KGB000860',
            'KGB000859',
            'KGB000858',
            'KGBD000294',
            'KGB004803',
            'KGBD001023',
            'KGBD001022',
            'KGBD001021',
            'KGBD001020',
            'KGBD001019',
            'KGB008539',
            'KGB008540',
            'KGB008541',
            'KGB008542',
            'KGB008543',
            'KGB008544',
            'KGB008545',
            'KGB008546',
            'KGB008547',
            'KGB008548',
            'KGB008549',
            'KGB008550',
            'KGB008551',
            'KGB008552',
            'KGB008553',
            'KGB008554',
            'KGBD007228',
            'KGBD007230',
            'KGBD007232',
            'KGBD007235',
            'KGBD007234',
            'KGBD007236',
            'KGBD007237',
            'KGBD007240',
            'KGBD007238',
            'KGB004548',
            'KGBD077886',
            'KGB000814',
            'KGBD013914',
            'KGBD091495',
            'KGBD098567',
            'KGBD009071',
            'KGB001727',
            'KGB001728',
            'KGB001729',
            'KGB001730',
            'KGB000973',
            'KGB000974',
            'KGB000975',
            'KGB000976',
            'KGB004804',
            'KGB004805',
            'KGB004806',
            'KGB004808',
            'KGBD006640',
            'KGBD036856',
            'KGBD036938',
            'KGBD004956',
            'KGBD004955',
            'KGBD004958',
            'KGBD017850',
            'KGBD017851',
            'KGBD037682',
            'KGBD037683',
            'KGBD037684',
            'KGBD037686',
            'KGBD037687',
            'KGBD037688',
            'KGBD000744',
            'KGBD000745',
            'KGBD000746',
            'KGB000882',
            'KGBD000241',
            'KGBD000319',
            'KGB000854',
            'KGBD000398',
            'KGBD000639',
            'KGBD000651',
            'KGBD000652',
            'KGB004092',
            'KGB004093',
            'KGB001688',
            'KGBD002657',
            'KGBD002658',
            'KGBD002940',
            'KGBD005373',
            'KGBD005372',
            'KGBD005371',
            'KGB004095',
            'KGB004809',
            'KGBD003631',
            'KGBD003632',
            'KGBD003667',
            'KGBD003668',
            'KGBD003669',
            'KGBD003670',
            'KGBD003671',
            'KGBD003672',
            'KGBD003673',
            'KGBD013358',
            'KGBD015474',
            'KGBD015477',
            'KGBD028662',
            'KGBD028663',
            'KGBD028664',
            'KGB000932',
            'KGB000931',
            'KGB000956',
            'KGBD000158',
            'KGBD000161',
            'KGBD000165',
            'KGB000950',
            'KGB000949',
            'KGB000948',
            'KGB000947',
            'KGB000952',
            'KGB000953',
            'KGB000951',
            'KGB000954',
            'KGB000955',
            'KGBD000197',
            'KGBD000202',
            'KGBD000214',
            'KGB000959',
            'KGB000934',
            'KGB000935',
            'KGB000957',
            'KGBD000228',
            'KGBD000152',
            'KGBD000234',
            'KGB000939',
            'KGBD000237',
            'KGB000946',
            'KGBD000238',
            'KGB000945',
            'KGB000943',
            'KGBD000006',
            'KGB000960',
            'KGB000936',
            'KGB000937',
            'KGB000941',
            'KGB000940',
            'KGBD000007',
            'KGB000958',
            'KGB000933',
            'KGB000938',
            'KGB004459',
            'KGBD004078',
            'KGBD004178',
            'KGBD005055',
            'KGBD005056',
            'KGBD005057',
            'KGBD005058',
            'KGBD005062',
            'KGBD005063',
            'KGBD005064',
            'KGBD005070',
            'KGBD005076',
            'KGBD005077',
            'KGBD005182',
            'KGBD017354',
            'KGBD034944',
            'KGBD034945',
            'KGBD034975',
            'KGBD034976',
            'KGBD034977',
            'KGBD034979',
            'KGBD034998',
            'KGBD034999',
            'KGBD035000',
            'KGBD035001',
            'KGBD035227',
            'KGBD035229',
            'KGBD035230',
            'KGBD036173',
            'KGBD036174',
            'KGBD036175',
            'KGBD039711',
            'KGBD042811',
            'KGBD042821',
            'KGBD042827',
            'KGBD057606',
            'KGBD057607',
            'KGBD057608',
            'KGBD057609',
            'KGBD060282',
            'KGBD074303',
            'KGBD074302',
            'KGBD074494',
            'KGBD075434',
            'KGBD075872',
            'KGBD075871',
            'KGBD023560',
            'KGBD023562',
            'KGBD078168',
            'KGBD079344',
            'KGBD079346',
            'KGBD023559',
            'KGBD079852',
            'KGBD079851',
            'KGBD082409',
            'KGBD094428',
            'KGBD094430',
            'KGBD094437',
            'KGBD094447',
            'KGBD094448',
            'KGBD094449',
            'KGBD102280',
            'KGBD102281',
            'KGBD102282',
            'KGBD102283',
            'KGBD102287',
            'KGBD035204',
            'KGBD035207',
            'KGBD035213',
            'KGBD103014',
            'KGBD103015',
            'KGBD103016',
            'KGBD103017',
            'KGBD104243',
            'KGBD104406',
            'KGBD104407',
            'KGBD112385',
            'KGBD112389',
            'KGBD112390',
            'KGBD130641',
            'KGBD130642',
            'KGBD151102',
            'KGBD151101',
            'KGBD151103',
            'KGBD151100',
            'KGBD167617',
            'KGBD175201',
            'KGBD175202',
            'KGBD176684',
            'KGBD192588',
            'KGBD193865',
            'KGBD193866',
            'KGBD193867',
            'KGBD023557',
            'KGBD204589',
            'KGBD210212',
            'KGBD210213',
            'KGBD210215',
            'KGBD210214',
            'KGBD210361',
            'KGBD212817',
            'KGBD053687',
            'KGBD053688',
            'KGBD053689',
            'KGB000963',
            'KGBD000800',
            'KGB000979',
            'KGB000980',
            'KGB000981',
            'KGB000982',
            'KGB000983',
            'KGB000985',
            'KGB000986',
            'KGBD011258',
            'KGBD011260',
            'KGBD011261',
            'KGBD000041',
            'KGB001008',
            'KGB001010',
            'KGB001011',
            'KGB001049',
            'KGB001050',
            'KGB001072',
            'KGB001073',
            'KGB001074',
            'KGB001211',
            'KGB001220',
            'KGB001281',
            'KGB001282',
            'KGB000881',
            'KGB000884',
            'KGB000880',
            'KGB000015',
            'KGB000022',
            'KGB000021',
            'KGB000020',
            'KGB000012',
            'KGB000013',
            'KGB000014',
            'KGB000023',
            'KGB000024',
            'KGB000016',
            'KGB000025',
            'KGB000017',
            'KGB000018',
            'KGB000019',
            'KGB000911',
            'KGBD001562',
            'KGBD006426',
            'KGB007073',
            'KGB008349',
            'KGB008350',
            'KGB008351',
            'KGB008352',
            'KGBD001737',
            'KGB003027',
            'KGB003018',
            'KGB003019',
            'KGB003020',
            'KGB003013',
            'KGB003014',
            'KGB003015',
            'KGB003016',
            'KGB003017',
            'KGBD007624',
            'KGBD007630',
            'KGBD010696',
            'KGBD010697',
            'KGBD013906',
            'KGBD014787',
            'KGBD015517',
            'KGBD000226',
            'KGB000111',
            'KGB000110',
            'KGBD000397',
            'KGBD000405',
            'KGBD000404',
            'KGBD000328',
            'KGB000617',
            'KGBD000799',
            'KGB004833',
            'KGB004901',
            'KGB004908',
            'KGBD000243',
            'KGBD000679',
            'KGBD000680',
            'KGBD000681',
            'KGBD000682',
            'KGBD000683',
            'KGBD000947',
            'KGBD000946',
            'KGB004041',
            'KGB001768',
            'KGB001767',
            'KGB000802',
            'KGB000810',
            'KGB000805',
            'KGB000808',
            'KGB000807',
            'KGB000806',
            'KGB000809',
            'KGB000700',
            'KGBD000297',
            'KGB000714',
            'KGBD000329',
            'KGBD001908',
            'KGB004388',
            'KGB004389',
            'KGB004390',
            'KGB004391',
            'KGB004392',
            'KGB004393',
            'KGB004394',
            'KGB004395',
            'KGB004396',
            'KGB004397',
            'KGB004398',
            'KGB004399',
            'KGBD005149',
            'KGBD007193',
            'KGBD007196',
            'KGBD012636',
            'KGB008148',
            'KGB006947',
            'KGB006948',
            'KGB006949',
            'KGB006950',
            'KGB006951',
            'KGB006952',
            'KGB006953',
            'KGB006955',
            'KGB006956',
            'KGB008284',
            'KGB008285',
            'KGB008286',
            'KGB003731',
            'KGB003732',
            'KGB003733',
            'KGB003734',
            'KGB003735',
            'KGB003736',
            'KGB003737',
            'KGB003738',
            'KGB003739',
            'KGB003740',
            'KGB003741',
            'KGBD008284',
            'KGBD007995',
            'KGBD018874',
            'KGBD023862',
            'KGBD023863',
            'KGBD023864',
            'KGBD023865',
            'KGBD023866',
            'KGBD029058',
            'KGBD000320',
            'KGBD000321',
            'KGBD000322',
            'KGBD000323',
            'KGBD000324',
            'KGBD000325',
            'KGBD000326',
            'KGBD000327',
            'KGBD025806',
            'KGBD236931',
            'KGBD236932',
            'KGBD236933',
            'KGBD236934',
            'KGBD007038',
            'KGBD046736',
            'KGBD042176',
            'KGBD046732',
            'KGBD042175',
            'KGBD000219',
            'KGB000871',
            'KGBD000231',
            'KGB000879',
            'KGBD000233',
            'KGB000867',
            'KGB000863',
            'KGB000868',
            'KGB000866',
            'KGB000864',
            'KGB000869',
            'KGB000870',
            'KGB000865',
            'KGB000872',
            'KGB000873',
            'KGBD000605',
            'KGBD000778',
            'KGBD000994',
            'KGBD002290',
            'KGBD002957',
            'KGBD002958',
            'KGBD003691',
            'KGBD004658',
            'KGBD006859',
            'KGBD006867',
            'KGBD006873',
            'KGBD006875',
            'KGBD006914',
            'KGBD001398',
            'KGBD001399',
            'KGBD001400',
            'KGBD001401',
            'KGBD001403',
            'KGBD001529',
            'KGBD001530',
            'KGBD001532',
            'KGBD001531',
            'KGBD016887',
            'KGBD016885',
            'KGBD002549',
            'KGBD002548',
            'KGBD010445',
            'KGBD010937',
            'KGBD018497',
            'KGBD018498',
            'KGBD026081',
            'KGBD026620',
            'KGBD026619',
            'KGBD026825',
            'KGBD026826',
            'KGBD002558',
            'KGBD002559',
            'KGBD002560',
            'KGBD002561',
            'KGBD002562',
            'KGBD002563',
            'KGBD002564',
            'KGBD002565',
            'KGBD002810',
            'KGBD002811',
            'KGBD002812',
            'KGBD002813',
            'KGBD002814',
            'KGBD002815',
            'KGBD002816',
            'KGBD002817',
            'KGBD002818',
            'KGBD002819',
            'KGBD002820',
            'KGBD003260',
            'KGBD001698',
            'KGBD001699',
            'KGBD001700',
            'KGBD001701',
            'KGBD001702',
            'KGBD002299',
            'KGBD003283',
            'KGBD003319',
            'KGBD003317',
            'KGBD083479',
            'KGBD083481',
            'KGBD083482',
            'KGBD115124',
            'KGBD228561',
            'KGBD006869',
            'KGBD002576',
            'KGBD000932',
            'KGBD000934',
            'KGBD000935',
            'KGBD000937',
            'KGBD012461',
            'KGBD012469',
            'KGBD012477',
            'KGBD025929',
            'KGBD001783',
            'KGBD001852',
            'KGBD001853',
            'KGBD001870',
            'KGBD001871',
            'KGBD001883',
            'KGBD001892',
            'KGBD001893',
            'KGBD001894',
            'KGBD001895',
            'KGBD001896',
            'KGBD001902',
            'KGBD001901',
            'KGBD001900',
            'KGBD001899',
            'KGBD001898',
            'KGBD001897',
            'KGBD001914',
            'KGBD001915',
            'KGBD001916',
            'KGBD001917',
            'KGBD001918',
            'KGBD001919',
            'KGBD001920',
            'KGBD001921',
            'KGBD001851',
            'KGBD003977',
            'KGBD003976',
            'KGBD003975',
            'KGBD003974',
            'KGBD003972',
            'KGBD003968',
            'KGBD003965',
            'KGBD005363',
            'KGBD005364',
            'KGBD005365',
            'KGBD005366',
            'KGBD006505',
            'KGBD006506',
            'KGBD006507',
            'KGBD006508',
            'KGBD006509',
            'KGBD005843',
            'KGBD005844',
            'KGBD005847',
            'KGBD005850',
            'KGBD005851',
            'KGBD005852',
            'KGBD005853',
            'KGBD005854',
            'KGBD005856',
            'KGBD005498',
            'KGBD005499',
            'KGBD005500',
            'KGBD005501',
            'KGBD005502',
            'KGBD005503',
            'KGBD005504',
            'KGBD005505',
            'KGBD005506',
            'KGBD005507',
            'KGBD005508',
            'KGBD005509',
            'KGBD005510',
            'KGBD005511',
            'KGBD005512',
            'KGBD005814',
            'KGBD072066',
            'KGBD072071',
            'KGBD072076',
            'KGBD141295',
            'KGBD194494',
            'KGBD130639',
            'KGBD221290',
            'KGBD148946',
            'KGBD006182',
            'KGBD006183',
            'KGBD006184',
            'KGBD006185',
            'KGBD006186',
            'KGBD006187',
            'KGBD006188',
            'KGBD006189',
            'KGBD006190',
            'KGBD006191',
            'KGBD006205',
            'KGBD006970',
            'KGBD007199',
            'KGBD010605',
            'KGBD023852',
            'KGBD023853',
            'KGBD023854',
            'KGBD023855',
            'KGBD023856',
            'KGBD030826',
            'KGBD006687',
            'KGBD006684',
            'KGBD006688',
            'KGBD006689',
            'KGBD006690',
            'KGBD006691',
            'KGBD012140',
            'KGBD024274',
            'KGBD024275',
            'KGBD024730',
            'KGBD035397',
            'KGBD111155',
            'KGBD111527',
            'KGBD111528',
            'KGBD111529',
            'KGBD111530',
            'KGBD111531',
            'KGBD111532',
            'KGBD111533',
            'KGBD111534',
            'KGBD008485',
            'KGBD008486',
            'KGBD008487',
            'KGBD008488',
            'KGBD008489',
            'KGBD008491',
            'KGBD008492',
            'KGBD008493',
            'KGBD010816',
            'KGBD011217',
            'KGBD011218',
            'KGBD012010',
            'KGBD012018',
            'KGBD012023',
            'KGBD012025',
            'KGBD012602',
            'KGBD025217',
            'KGBD026423',
            'KGBD026426',
            'KGBD026431',
            'KGBD027166',
            'KGBD027168',
            'KGBD007808',
            'KGBD007806',
            'KGBD025554',
            'KGBD025555',
            'KGBD017206',
            'KGBD017234',
            'KGBD017295',
            'KGBD017297',
            'KGBD219243',
            'KGBD219242',
            'KGBD219241',
            'KGBD219240',
            'KGBD219239',
            'KGBD008452',
            'KGBD008455',
            'KGBD008461',
            'KGBD025321',
            'KGBD028415',
            'KGBD028989',
            'KGBD028990',
            'KGBD028991',
            'KGBD028992',
            'KGBD039992',
            'KGBD013856',
            'KGBD008985',
            'KGBD008998',
            'KGBD008999',
            'KGBD009000',
            'KGBD009001',
            'KGBD009002',
            'KGBD009004',
            'KGBD009003',
            'KGBD009005',
            'KGBD009006',
            'KGBD012141',
            'KGBD012142',
            'KGBD012143',
            'KGBD012960',
            'KGBD072670',
            'KGBD072669',
            'KGBD072668',
            'KGBD072667',
            'KGBD072666',
            'KGBD072664',
            'KGBD072663',
            'KGBD072662',
            'KGBD072552',
            'KGBD072551',
            'KGBD072550',
            'KGBD072549',
            'KGBD009029',
            'KGBD015607',
            'KGBD015606',
            'KGBD075018',
            'KGBD074565',
            'KGBD074564',
            'KGBD074551',
            'KGBD074563',
            'KGBD030359',
            'KGBD075075',
            'KGBD075074',
            'KGBD074550',
            'KGBD074549',
            'KGBD074547',
            'KGBD074548',
            'KGBD074546',
            'KGBD074545',
            'KGBD074570',
            'KGBD074569',
            'KGBD074568',
            'KGBD074566',
            'KGBD074567',
            'KGBD075089',
            'KGBD075093',
            'KGBD075094',
            'KGBD075095',
            'KGBD075096',
            'KGBD075097',
            'KGBD075098',
            'KGBD075099',
            'KGBD075100',
            'KGBD075101',
            'KGBD077505',
            'KGBD077507',
            'KGBD077510',
            'KGBD077509',
            'KGBD077511',
            'KGBD080775',
            'KGBD080776',
            'KGBD080777',
            'KGBD080778',
            'KGBD080779',
            'KGBD080780',
            'KGBD080781',
            'KGBD080782',
            'KGBD080783',
            'KGBD080784',
            'KGBD080785',
            'KGBD080786',
            'KGBD080787',
            'KGBD080788',
            'KGBD009144',
            'KGBD010105',
            'KGBD010228',
            'KGBD010478',
            'KGBD010676',
            'KGBD015391',
            'KGBD017300',
            'KGBD017302',
            'KGBD023493',
            'KGBD028758',
            'KGBD041285',
            'KGBD041681',
            'KGBD041915',
            'KGBD042484',
            'KGBD042475',
            'KGBD063439',
            'KGBD063440',
            'KGBD009583',
            'KGBD009584',
            'KGBD009585',
            'KGBD009796',
            'KGBD009797',
            'KGBD009798',
            'KGBD009799',
            'KGBD009800',
            'KGBD009801',
            'KGBD009803',
            'KGBD009804',
            'KGBD009805',
            'KGBD009806',
            'KGBD009898',
            'KGBD009897',
            'KGBD009899',
            'KGBD009915',
            'KGBD009910',
            'KGBD010002',
            'KGBD010001',
            'KGBD009794',
            'KGBD009807',
            'KGBD009808',
            'KGBD009809',
            'KGBD009810',
            'KGBD009987',
            'KGBD009992',
            'KGBD009991',
            'KGBD009990',
            'KGBD009989',
            'KGBD009988',
            'KGBD010014',
            'KGBD010013',
            'KGBD010012',
            'KGBD010011',
            'KGBD010009',
            'KGBD010008',
            'KGBD015127',
            'KGBD015149',
            'KGBD010432',
            'KGBD010610',
            'KGBD010611',
            'KGBD010877',
            'KGBD010608',
            'KGBD011071',
            'KGBD010879',
            'KGBD010880',
            'KGBD010881',
            'KGBD012473',
            'KGBD012491',
            'KGBD012119',
            'KGBD012120',
            'KGBD012121',
            'KGBD012144',
            'KGBD012145',
            'KGBD012198',
            'KGBD012199',
            'KGBD012235',
            'KGBD012337',
            'KGBD012338',
            'KGBD012340',
            'KGBD012341',
            'KGBD012342',
            'KGBD012343',
            'KGBD012344',
            'KGBD014463',
            'KGBD016621',
            'KGBD024109',
            'KGBD027140',
            'KGBD028003',
            'KGBD028037',
            'KGBD028058',
            'KGBD028194',
            'KGBD012281',
            'KGBD012282',
            'KGBD012283',
            'KGBD012358',
            'KGBD012361',
            'KGBD012362',
            'KGBD012312',
            'KGBD012313',
            'KGBD012314',
            'KGBD012315',
            'KGBD012318',
            'KGBD012319',
            'KGBD012320',
            'KGBD012321',
            'KGBD012322',
            'KGBD012323',
            'KGBD012324',
            'KGBD012325',
            'KGBD012326',
            'KGBD012327',
            'KGBD012454',
            'KGBD012455',
            'KGBD012456',
            'KGBD012460',
            'KGBD012457',
            'KGBD012458',
            'KGBD012459',
            'KGBD014464',
            'KGBD014465',
            'KGBD014466',
            'KGBD014467',
            'KGBD014468',
            'KGBD014469',
            'KGBD014470',
            'KGBD018235',
            'KGBD012703',
            'KGBD012704',
            'KGBD012705',
            'KGBD012706',
            'KGBD012707',
            'KGBD012708',
            'KGBD012709',
            'KGBD012710',
            'KGBD012711',
            'KGBD013088',
            'KGBD012674',
            'KGBD185601',
            'KGBD015460',
            'KGBD015461',
            'KGBD015462',
            'KGBD015463',
            'KGBD016809',
            'KGBD016810',
            'KGBD016811',
            'KGBD016814',
            'KGBD017514',
            'KGBD017515',
            'KGBD017516',
            'KGBD017517',
            'KGBD025627',
            'KGBD027838',
            'KGBD036342',
            'KGBD015597',
            'KGBD015599',
            'KGBD015868',
            'KGBD015871',
            'KGBD015873',
            'KGBD015875',
            'KGBD015876',
            'KGBD015881',
            'KGBD015882',
            'KGBD015883',
            'KGBD015884',
            'KGBD015886',
            'KGBD015893',
            'KGBD015897',
            'KGBD015902',
            'KGBD015911',
            'KGBD015922',
            'KGBD015928',
            'KGBD015931',
            'KGBD015937',
            'KGBD015941',
            'KGBD015945',
            'KGBD015954',
            'KGBD098840',
            'KGBD098841',
            'KGBD098842',
            'KGBD101298',
            'KGBD102048',
            'KGBD016769',
            'KGBD016771',
            'KGBD016772',
            'KGBD016773',
            'KGBD016774',
            'KGBD016775',
            'KGBD016779',
            'KGBD016781',
            'KGBD016860',
            'KGBD016861',
            'KGBD016862',
            'KGBD016863',
            'KGBD016864',
            'KGBD016865',
            'KGBD033852',
            'KGBD016914',
            'KGBD016913',
            'KGBD016981',
            'KGBD016982',
            'KGBD016985',
            'KGBD016986',
            'KGBD016987',
            'KGBD016989',
            'KGBD017012',
            'KGBD017105',
            'KGBD017107',
            'KGBD017109',
            'KGBD017110',
            'KGBD016983',
            'KGBD016984',
            'KGBD017218',
            'KGBD017220',
            'KGBD017221',
            'KGBD017222',
            'KGBD017223',
            'KGBD017364',
            'KGBD018466',
            'KGBD018477',
            'KGBD018478',
            'KGBD018479',
            'KGBD018480',
            'KGBD018483',
            'KGBD018484',
            'KGBD021015',
            'KGBD021159',
            'KGBD024603',
            'KGBD024580',
            'KGBD024655',
            'KGBD061274',
            'KGBD061260',
            'KGBD123929',
            'KGBD123933',
            'KGBD123951',
            'KGBD123952',
            'KGBD123953',
            'KGBD123954',
            'KGBD123975',
            'KGBD123976',
            'KGBD123386',
            'KGBD123387',
            'KGBD044080',
            'KGBD125290',
            'KGBD024298',
            'KGBD024296',
            'KGBD074999',
            'KGBD075539',
            'KGBD075537',
            'KGBD075538',
            'KGBD137555',
            'KGBD137556',
            'KGBD136892',
            'KGBD024007',
            'KGBD024010',
            'KGBD024012',
            'KGBD178342',
            'KGBD178343',
            'KGBD206543',
            'KGBD206540',
            'KGBD206542',
            'KGBD206541',
            'KGBD218272',
            'KGBD218271',
            'KGBD218270',
            'KGBD218269',
            'KGBD218638',
            'KGBD218637',
            'KGBD218893',
            'KGBD218891',
            'KGBD218892',
            'KGBD218956',
            'KGBD227987',
            'KGBD232485',
            'KGBD232484',
            'KGBD232486',
            'KGBD232483',
            'KGBD245033',
            'KGBD245032',
            'KGBD219702',
            'KGBD026319',
            'KGBD026328',
            'KGBD026352',
            'KGBD026353',
            'KGBD026354',
            'KGBD026361',
            'KGBD026362',
            'KGBD026363',
            'KGBD032401',
            'KGBD040872',
            'KGBD040873',
            'KGBD040898',
            'KGBD040900',
            'KGBD040902',
            'KGBD040952',
            'KGBD040954',
            'KGBD040957',
            'KGBD047876',
            'KGBD070270',
            'KGBD070449',
            'KGBD084787',
            'KGBD025662',
            'KGBD025954',
            'KGBD027594',
            'KGBD027595',
            'KGBD027596',
            'KGBD027597',
            'KGBD027598',
            'KGBD027599',
            'KGBD027600',
            'KGBD027601',
            'KGBD027602',
            'KGBD027603',
            'KGBD027604',
            'KGBD027605',
            'KGBD027606',
            'KGBD027607',
            'KGBD027608',
            'KGBD027609',
            'KGBD027610',
            'KGBD027611',
            'KGBD027612',
            'KGBD027824',
            'KGBD028651',
            'KGBD028653',
            'KGBD032922',
            'KGBD032925',
            'KGBD033164',
            'KGBD038444',
            'KGBD038440',
            'KGBD027819',
            'KGBD027820',
            'KGBD027821',
            'KGBD027822',
            'KGBD029133',
            'KGBD039198',
            'KGBD074693',
            'KGBD074704',
            'KGBD031497',
            'KGBD035427',
            'KGBD035432',
            'KGBD035437',
            'KGBD035439',
            'KGBD035441',
            'KGBD035443',
            'KGBD035458',
            'KGBD035460',
            'KGBD035461',
            'KGBD035462',
            'KGBD035463',
            'KGBD035474',
            'KGBD035475',
            'KGBD035476',
            'KGBD035478',
            'KGBD035477',
            'KGBD035542',
            'KGBD035543',
            'KGBD035544',
            'KGBD041440',
            'KGBD048502',
            'KGBD048503',
            'KGBD048505',
            'KGBD048504',
            'KGBD049363',
            'KGBD049364',
            'KGBD049365',
            'KGBD049367',
            'KGBD049368',
            'KGBD051024',
            'KGBD051025',
            'KGBD051026',
            'KGBD051030',
            'KGBD051029',
            'KGBD051027',
            'KGBD052393',
            'KGBD052394',
            'KGBD052395',
            'KGBD052396',
            'KGBD052397',
            'KGBD052398',
            'KGBD052399',
            'KGBD052400',
            'KGBD052401',
            'KGBD052402',
            'KGBD044579',
            'KGBD044578',
            'KGBD044577',
            'KGBD044576',
            'KGBD055016',
            'KGBD055017',
            'KGBD055018',
            'KGBD048518',
            'KGBD051555',
            'KGBD056385',
            'KGBD056386',
            'KGBD056201',
            'KGBD056202',
            'KGBD056402',
            'KGBD056403',
            'KGBD056404',
            'KGBD056405',
            'KGBD056406',
            'KGBD056407',
            'KGBD056408',
            'KGBD056409',
            'KGBD066374',
            'KGBD120667',
            'KGBD069183',
            'KGBD069184',
            'KGBD069188',
            'KGBD069185',
            'KGBD065437',
            'KGBD069325',
            'KGBD069324',
            'KGBD069169',
            'KGBD069103',
            'KGBD069170',
            'KGBD069432',
            'KGBD069433',
            'KGBD069437',
            'KGBD069436',
            'KGBD069439',
            'KGBD069440',
            'KGBD069344',
            'KGBD069331',
            'KGBD064053',
            'KGBD064047',
            'KGBD069346',
            'KGBD069349',
            'KGBD070066',
            'KGBD070065',
            'KGBD070061',
            'KGBD070060',
            'KGBD069345',
            'KGBD071956',
            'KGBD071955',
            'KGBD071954',
            'KGBD064697',
            'KGBD069171',
            'KGBD075139',
            'KGBD075140',
            'KGBD075141',
            'KGBD075143',
            'KGBD075144',
            'KGBD075145',
            'KGBD075150',
            'KGBD068941',
            'KGBD068938',
            'KGBD065922',
            'KGBD065923',
            'KGBD065924',
            'KGBD065925',
            'KGBD072646',
            'KGBD076484',
            'KGBD076834',
            'KGBD076836',
            'KGBD075137',
            'KGBD075138',
            'KGBD080891',
            'KGBD065436',
            'KGBD081789',
            'KGBD081825',
            'KGBD079380',
            'KGBD082423',
            'KGBD083580',
            'KGBD083575',
            'KGBD085688',
            'KGBD085682',
            'KGBD085681',
            'KGBD085679',
            'KGBD085678',
            'KGBD085685',
            'KGBD085684',
            'KGBD085683',
            'KGBD069181',
            'KGBD086663',
            'KGBD069182',
            'KGBD090144',
            'KGBD091385',
            'KGBD094174',
            'KGBD094173',
            'KGBD094172',
            'KGBD095059',
            'KGBD096093',
            'KGBD085686',
            'KGBD096094',
            'KGBD097925',
            'KGBD085529',
            'KGBD064120',
            'KGBD082829',
            'KGBD082523',
            'KGBD082526',
            'KGBD104400',
            'KGBD104446',
            'KGBD104447',
            'KGBD104448',
            'KGBD104423',
            'KGBD104444',
            'KGBD065570',
            'KGBD065584',
            'KGBD065579',
            'KGBD065576',
            'KGBD109070',
            'KGBD109347',
            'KGBD109348',
            'KGBD065439',
            'KGBD082631',
            'KGBD119768',
            'KGBD070062',
            'KGBD128292',
            'KGBD128295',
            'KGBD129400',
            'KGBD079485',
            'KGBD123738',
            'KGBD099948',
            'KGBD122795',
            'KGBD130673',
            'KGBD130760',
            'KGBD130755',
            'KGBD130735',
            'KGBD130727',
            'KGBD113484',
            'KGBD130687',
            'KGBD130750',
            'KGBD130700',
            'KGBD130763',
            'KGBD130752',
            'KGBD130707',
            'KGBD089979',
            'KGBD089149',
            'KGBD079803',
            'KGBD079802',
            'KGBD087581',
            'KGBD130695',
            'KGBD131691',
            'KGBD131809',
            'KGBD131810',
            'KGBD131813',
            'KGBD131816',
            'KGBD131815',
            'KGBD087585',
            'KGBD087583',
            'KGBD087582',
            'KGBD092068',
            'KGBD093865',
            'KGBD093872',
            'KGBD129519',
            'KGBD075971',
            'KGBD118531',
            'KGBD131819',
            'KGBD131820',
            'KGBD131821',
            'KGBD129394',
            'KGBD081164',
            'KGBD128353',
            'KGBD132256',
            'KGBD132257',
            'KGBD132260',
            'KGBD132259',
            'KGBD132258',
            'KGBD130709',
            'KGBD132261',
            'KGBD132262',
            'KGBD132403',
            'KGBD079456',
            'KGBD082430',
            'KGBD130859',
            'KGBD112181',
            'KGBD085762',
            'KGBD105804',
            'KGBD105836',
            'KGBD105787',
            'KGBD075945',
            'KGBD075958',
            'KGBD075959',
            'KGBD064116',
            'KGBD132453',
            'KGBD132455',
            'KGBD130690',
            'KGBD081163',
            'KGBD132451',
            'KGBD131557',
            'KGBD070021',
            'KGBD132795',
            'KGBD090701',
            'KGBD068943',
            'KGBD068944',
            'KGBD130633',
            'KGBD130743',
            'KGBD130705',
            'KGBD130685',
            'KGBD132952',
            'KGBD120743',
            'KGBD132953',
            'KGBD112436',
            'KGBD112434',
            'KGBD112435',
            'KGBD123540',
            'KGBD123750',
            'KGBD127545',
            'KGBD127521',
            'KGBD090002',
            'KGBD123528',
            'KGBD128397',
            'KGBD128386',
            'KGBD132984',
            'KGBD132985',
            'KGBD077366',
            'KGBD133681',
            'KGBD133680',
            'KGBD133754',
            'KGBD130575',
            'KGBD133734',
            'KGBD134041',
            'KGBD136361',
            'KGBD134731',
            'KGBD132965',
            'KGBD136383',
            'KGBD140755',
            'KGBD081588',
            'KGBD149799',
            'KGBD090682',
            'KGBD094509',
            'KGBD060925',
            'KGBD060939',
            'KGBD061025',
            'KGBD061026',
            'KGBD061156',
            'KGBD061164',
            'KGBD061166',
            'KGBD061243',
            'KGBD061244',
            'KGBD061237',
            'KGBD061240',
            'KGBD061241',
            'KGBD061301',
            'KGBD061302',
            'KGBD061303',
            'KGBD061305',
            'KGBD061304',
            'KGBD061297',
            'KGBD061296',
            'KGBD061300',
            'KGBD061299',
            'KGBD061446',
            'KGBD061445',
            'KGBD061444',
            'KGBD061295',
            'KGBD061529',
            'KGBD061530',
            'KGBD061531',
            'KGBD063427',
            'KGBD066083',
            'KGBD066082',
            'KGBD077333',
            'KGBD077334',
            'KGBD077335',
            'KGBD077329',
            'KGBD077328',
            'KGBD077327',
            'KGBD077332',
            'KGBD077331',
            'KGBD077330',
            'KGBD062433',
            'KGBD116225',
            'KGBD116226',
            'KGBD116227',
            'KGBD116233',
            'KGBD116234',
            'KGBD116235',
            'KGBD116255',
            'KGBD116253',
            'KGBD116254',
            'KGBD116251',
            'KGBD116252',
            'KGBD116249',
            'KGBD116250',
            'KGBD116248',
            'KGBD116247',
            'KGBD116246',
            'KGBD116245',
            'KGBD116244',
            'KGBD116243',
            'KGBD116287',
            'KGBD116288',
            'KGBD116351',
            'KGBD116354',
            'KGBD146642',
            'KGBD146632',
            'KGBD187586',
            'KGBD187832',
            'KGBD193868',
            'KGBD193869',
            'KGBD212822',
            'KGBD212824',
            'KGBD212821',
            'KGBD212823',
            'KGBD243272',
            'KGBD249835',
            'KGBD249834',
            'KGBD249833',
            'KGBD249836',
            'KGBD062842',
            'KGBD062841',
            'KGBD062840',
            'KGBD062839',
            'KGBD062862',
            'KGBD062863',
            'KGBD062864',
            'KGBD067310',
            'KGBD067095',
            'KGBD067096',
            'KGBD067097',
            'KGBD067094',
            'KGBD067093',
            'KGBD067092',
            'KGBD067091',
            'KGBD067089',
            'KGBD067090',
            'KGBD067313',
            'KGBD068054',
            'KGBD068055',
            'KGBD068056',
            'KGBD068057',
            'KGBD068058',
            'KGBD068059',
            'KGBD068060',
            'KGBD068061',
            'KGBD068062',
            'KGBD066689',
            'KGBD066690',
            'KGBD066691',
            'KGBD066692',
            'KGBD066693',
            'KGBD066694',
            'KGBD066725',
            'KGBD067066',
            'KGBD067067',
            'KGBD067068',
            'KGBD067069',
            'KGBD097897',
            'KGBD068440',
            'KGBD068441',
            'KGBD070518',
            'KGBD070519',
            'KGBD070520',
            'KGBD070521',
            'KGBD069357',
            'KGBD075177',
            'KGBD075214',
            'KGBD077426',
            'KGBD077427',
            'KGBD077429',
            'KGBD077890',
            'KGBD077889',
            'KGBD077894',
            'KGBD077895',
            'KGBD077896',
            'KGBD077525',
            'KGBD077522',
            'KGBD077521',
            'KGBD079050',
            'KGBD079051',
            'KGBD079052',
            'KGBD079062',
            'KGBD079061',
            'KGBD079063',
            'KGBD079154',
            'KGBD079157',
            'KGBD079156',
            'KGBD079155',
            'KGBD079151',
            'KGBD079317',
            'KGBD079318',
            'KGBD079320',
            'KGBD079319',
            'KGBD079330',
            'KGBD079322',
            'KGBD079323',
            'KGBD079391',
            'KGBD079392',
            'KGBD079393',
            'KGBD079394',
            'KGBD082814',
            'KGBD083191',
            'KGBD084324',
            'KGBD084326',
            'KGBD084325',
            'KGBD084327',
            'KGBD084328',
            'KGBD084329',
            'KGBD084330',
            'KGBD084331',
            'KGBD084332',
            'KGBD084338',
            'KGBD084340',
            'KGBD084342',
            'KGBD084339',
            'KGBD084649',
            'KGBD085736',
            'KGBD077891',
            'KGBD086282',
            'KGBD086283',
            'KGBD086284',
            'KGBD086503',
            'KGBD086502',
            'KGBD086520',
            'KGBD086968',
            'KGBD090146',
            'KGBD092102',
            'KGBD093200',
            'KGBD093202',
            'KGBD093203',
            'KGBD093204',
            'KGBD094336',
            'KGBD094337',
            'KGBD094338',
            'KGBD094339',
            'KGBD094340',
            'KGBD094513',
            'KGBD094600',
            'KGBD094811',
            'KGBD095009',
            'KGBD095282',
            'KGBD099723',
            'KGBD099722',
            'KGBD099721',
            'KGBD099724',
            'KGBD100137',
            'KGBD101290',
            'KGBD101289',
            'KGBD101288',
            'KGBD104702',
            'KGBD104763',
            'KGBD106610',
            'KGBD106943',
            'KGBD114038',
            'KGBD114039',
            'KGBD114050',
            'KGBD114051',
            'KGBD114042',
            'KGBD114041',
            'KGBD114040',
            'KGBD114052',
            'KGBD114053',
            'KGBD114054',
            'KGBD114055',
            'KGBD114385',
            'KGBD114386',
            'KGBD114387',
            'KGBD114388',
            'KGBD091448',
            'KGBD114608',
            'KGBD133351',
            'KGBD136717',
            'KGBD139195',
            'KGBD139194',
            'KGBD139196',
            'KGBD139197',
            'KGBD139199',
            'KGBD139801',
            'KGBD139802',
            'KGBD139803',
            'KGBD139804',
            'KGBD149606',
            'KGBD175206',
            'KGBD190839',
            'KGBD091646',
            'KGBD193195',
            'KGBD197027',
            'KGBD197028',
            'KGBD203852',
            'KGBD203850',
            'KGBD203849',
            'KGBD203851',
            'KGBD204130',
            'KGBD203867',
            'KGBD204133',
            'KGBD204131',
            'KGBD204132',
            'KGBD175767',
            'KGBD175816',
            'KGBD175818',
            'KGBD204539',
            'KGBD208756',
            'KGBD226012',
            'KGBD228000',
            'KGBD243840',
            'KGBD243841',
            'KGBD243842',
            'KGBD244734',
            'KGBD244735',
            'KGBD245021',
            'KGBD073419',
            'KGBD073418',
            'KGBD073382',
            'KGBD073381',
            'KGBD094106',
            'KGBD091722',
            'KGBD100339',
            'KGBD104524',
            'KGBD232967',
            'KGBD109088',
            'KGBD109089',
            'KGBD075584',
            'KGBD078567',
            'KGBD078566',
            'KGBD078565',
            'KGBD078564',
            'KGBD083209',
            'KGBD112122',
            'KGBD117620',
            'KGBD139798',
            'KGBD143390',
            'KGBD149806',
            'KGBD149815',
            'KGBD149820',
            'KGBD149819',
            'KGBD149818',
            'KGBD149823',
            'KGBD149825',
            'KGBD149826',
            'KGBD149824',
            'KGBD149828',
            'KGBD151407',
            'KGBD173147',
            'KGBD173148',
            'KGBD173149',
            'KGBD173150',
            'KGBD173153',
            'KGBD173152',
            'KGBD173158',
            'KGBD173157',
            'KGBD173160',
            'KGBD173159',
            'KGBD173161',
            'KGBD173162',
            'KGBD173164',
            'KGBD173163',
            'KGBD173166',
            'KGBD173165',
            'KGBD173167',
            'KGBD173169',
            'KGBD173174',
            'KGBD173182',
            'KGBD173183',
            'KGBD186004',
            'KGBD186007',
            'KGBD186008',
            'KGBD186009',
            'KGBD186010',
            'KGBD186011',
            'KGBD186015',
            'KGBD186020',
            'KGBD186029',
            'KGBD186030',
            'KGBD186031',
            'KGBD186032',
            'KGBD186035',
            'KGBD186036',
            'KGBD186037',
            'KGBD186038',
            'KGBD116427',
            'KGBD141108',
            'KGBD141103',
            'KGBD141102',
            'KGBD141101',
            'KGBD141098',
            'KGBD141097',
            'KGBD141096',
            'KGBD142996',
            'KGBD083959',
            'KGBD094420',
            'KGBD094419',
            'KGBD089651',
            'KGBD134848',
            'KGBD090147',
            'KGBD203332',
            'KGBD199167',
            'KGBD136942',
            'KGBD106811',
            'KGBD106807',
            'KGBD120925',
            'KGBD123018',
            'KGBD134108',
            'KGBD186974',
            'KGBD109346',
            'KGBD109345',
            'KGBD109344',
            'KGBD109437',
            'KGBD177554',
            'KGBD092967',
            'KGBD092968',
            'KGBD092969',
            'KGBD093127',
            'KGBD093128',
            'KGBD093129',
            'KGBD092157',
            'KGBD092166',
            'KGBD092179',
            'KGBD096154',
            'KGBD096144',
            'KGBD096137',
            'KGBD096136',
            'KGBD096135',
            'KGBD096129',
            'KGBD091983',
            'KGBD091984',
            'KGBD104580',
            'KGBD092168',
            'KGBD114962',
            'KGBD115039',
            'KGBD115322',
            'KGBD115323',
            'KGBD115324',
            'KGBD119644',
            'KGBD120074',
            'KGBD120075',
            'KGBD120076',
            'KGBD120489',
            'KGBD120491',
            'KGBD120492',
            'KGBD120493',
            'KGBD120421',
            'KGBD120494',
            'KGBD120495',
            'KGBD120518',
            'KGBD120422',
            'KGBD120496',
            'KGBD120497',
            'KGBD120507',
            'KGBD120508',
            'KGBD120423',
            'KGBD133350',
            'KGBD133919',
            'KGBD133920',
            'KGBD133921',
            'KGBD092178',
            'KGBD136743',
            'KGBD136751',
            'KGBD136750',
            'KGBD136744',
            'KGBD136745',
            'KGBD142533',
            'KGBD142534',
            'KGBD142570',
            'KGBD178345',
            'KGBD182046',
            'KGBD182047',
            'KGBD091934',
            'KGBD091935',
            'KGBD091936',
            'KGBD091937',
            'KGBD091938',
            'KGBD091939',
            'KGBD091940',
            'KGBD091941',
            'KGBD091942',
            'KGBD091943',
            'KGBD091944',
            'KGBD091945',
            'KGBD091946',
            'KGBD093392',
            'KGBD093396',
            'KGBD093397',
            'KGBD093398',
            'KGBD093399',
            'KGBD093400',
            'KGBD093401',
            'KGBD093405',
            'KGBD093407',
            'KGBD093408',
            'KGBD093644',
            'KGBD093645',
            'KGBD093660',
            'KGBD093688',
            'KGBD093780',
            'KGBD093782',
            'KGBD093834',
            'KGBD093836',
            'KGBD093846',
            'KGBD093091',
            'KGBD093092',
            'KGBD093093',
            'KGBD093094',
            'KGBD093095',
            'KGBD093096',
            'KGBD093097',
            'KGBD093098',
            'KGBD093099',
            'KGBD093100',
            'KGBD093101',
            'KGBD093102',
            'KGBD093103',
            'KGBD093104',
            'KGBD093105',
            'KGBD093106',
            'KGBD093107',
            'KGBD093108',
            'KGBD093109',
            'KGBD093090',
            'KGBD177011',
            'KGBD178837',
            'KGBD178834',
            'KGBD178835',
            'KGBD178836',
            'KGBD114963',
            'KGBD118570',
            'KGBD123389',
            'KGBD123388',
            'KGBD136895',
            'KGBD110651',
            'KGBD150896',
            'KGBD150894',
            'KGBD150915',
            'KGBD126993',
            'KGBD121005',
            'KGBD161521',
            'KGBD155769',
            'KGBD155771',
            'KGBD155772',
            'KGBD155773',
            'KGBD155776',
            'KGBD155777',
            'KGBD166529',
            'KGBD166530',
            'KGBD095988',
            'KGBD095655',
            'KGBD182583',
            'KGBD101241',
            'KGBD102204',
            'KGBD102205',
            'KGBD102206',
            'KGBD102207',
            'KGBD102208',
            'KGBD102209',
            'KGBD186003',
            'KGBD216335',
            'KGBD096887',
            'KGBD096888',
            'KGBD098404',
            'KGBD099202',
            'KGBD136722',
            'KGBD139799',
            'KGBD115046',
            'KGBD117634',
            'KGBD117632',
            'KGBD117636',
            'KGBD133693',
            'KGBD133686',
            'KGBD133684',
            'KGBD110617',
            'KGBD099250',
            'KGBD134824',
            'KGBD098881',
            'KGBD136715',
            'KGBD145279',
            'KGBD099174',
            'KGBD098884',
            'KGBD171809',
            'KGBD098882',
            'KGBD099178',
            'KGBD098026',
            'KGBD109297',
            'KGBD099182',
            'KGBD145281',
            'KGBD125504',
            'KGBD202955',
            'KGBD220677',
            'KGBD098406',
            'KGBD102053',
            'KGBD110620',
            'KGBD114418',
            'KGBD116556',
            'KGBD116557',
            'KGBD098502',
            'KGBD098503',
            'KGBD098505',
            'KGBD098504',
            'KGBD098506',
            'KGBD098511',
            'KGBD115125',
            'KGBD121627',
            'KGBD121628',
            'KGBD125263',
            'KGBD124991',
            'KGBD124964',
            'KGBD124963',
            'KGBD182299',
            'KGBD182301',
            'KGBD182302',
            'KGBD182303',
            'KGBD100094',
            'KGBD100095',
            'KGBD100096',
            'KGBD100097',
            'KGBD100098',
            'KGBD100099',
            'KGBD100100',
            'KGBD100101',
            'KGBD100102',
            'KGBD100103',
            'KGBD100104',
            'KGBD100105',
            'KGBD100106',
            'KGBD100107',
            'KGBD100108',
            'KGBD101285',
            'KGBD101286',
            'KGBD140190',
            'KGBD257549',
            'KGBD102517',
            'KGBD102977',
            'KGBD104227',
            'KGBD104460',
            'KGBD109478',
            'KGBD109477',
            'KGBD109620',
            'KGBD109678',
            'KGBD110869',
            'KGBD114029',
            'KGBD114391',
            'KGBD127074',
            'KGBD136369',
            'KGBD136370',
            'KGBD136371',
            'KGBD136372',
            'KGBD136727',
            'KGBD136758',
            'KGBD139893',
            'KGBD143389',
            'KGBD174961',
            'KGBD178911',
            'KGBD181575',
            'KGBD114964',
            'KGBD114965',
            'KGBD114966',
            'KGBD136718',
            'KGBD136719',
            'KGBD136720',
            'KGBD136732',
            'KGBD136733',
            'KGBD136734',
            'KGBD136735',
            'KGBD136736',
            'KGBD119715',
            'KGBD133349',
            'KGBD134169',
            'KGBD140788',
            'KGBD140791',
            'KGBD182291',
            'KGBD104122',
            'KGBD104123',
            'KGBD104124',
            'KGBD104125',
            'KGBD104126',
            'KGBD104127',
            'KGBD104128',
            'KGBD104129',
            'KGBD104130',
            'KGBD104131',
            'KGBD104132',
            'KGBD104133',
            'KGBD104134',
            'KGBD104135',
            'KGBD104136',
            'KGBD103504',
            'KGBD103505',
            'KGBD103506',
            'KGBD103507',
            'KGBD103508',
            'KGBD103509',
            'KGBD103625',
            'KGBD128288',
            'KGBD128289',
            'KGBD104462',
            'KGBD104459',
            'KGBD104464',
            'KGBD104465',
            'KGBD104466',
            'KGBD104467',
            'KGBD104468',
            'KGBD104469',
            'KGBD104470',
            'KGBD104471',
            'KGBD104472',
            'KGBD104473',
            'KGBD104474',
            'KGBD104475',
            'KGBD104476',
            'KGBD104477',
            'KGBD104478',
            'KGBD104479',
            'KGBD104480',
            'KGBD104481',
            'KGBD119233',
            'KGBD106494',
            'KGBD106607',
            'KGBD106608',
            'KGBD106609',
            'KGBD106613',
            'KGBD106612',
            'KGBD106611',
            'KGBD106825',
            'KGBD106824',
            'KGBD114968',
            'KGBD117886',
            'KGBD117885',
            'KGBD141104',
            'KGBD108278',
            'KGBD108275',
            'KGBD108263',
            'KGBD108465',
            'KGBD108463',
            'KGBD108464',
            'KGBD108462',
            'KGBD115068',
            'KGBD115075',
            'KGBD115073',
            'KGBD115074',
            'KGBD126920',
            'KGBD108652',
            'KGBD109714',
            'KGBD134164',
            'KGBD173114',
            'KGBD112115',
            'KGBD112116',
            'KGBD111584',
            'KGBD135998',
            'KGBD135999',
            'KGBD136000',
            'KGBD111115',
            'KGBD112117',
            'KGBD112523',
            'KGBD112524',
            'KGBD112525',
            'KGBD112529',
            'KGBD117884',
            'KGBD118317',
            'KGBD118314',
            'KGBD118315',
            'KGBD118316',
            'KGBD118318',
            'KGBD118320',
            'KGBD118321',
            'KGBD118322',
            'KGBD118324',
            'KGBD118325',
            'KGBD118347',
            'KGBD118334',
            'KGBD118333',
            'KGBD118329',
            'KGBD134362',
            'KGBD135987',
            'KGBD135991',
            'KGBD149258',
            'KGBD149259',
            'KGBD149260',
            'KGBD166541',
            'KGBD166580',
            'KGBD172297',
            'KGBD111556',
            'KGBD120468',
            'KGBD120472',
            'KGBD119854',
            'KGBD121601',
            'KGBD121600',
            'KGBD121599',
            'KGBD121598',
            'KGBD121597',
            'KGBD123660',
            'KGBD123674',
            'KGBD124195',
            'KGBD128294',
            'KGBD128293',
            'KGBD128296',
            'KGBD133992',
            'KGBD134693',
            'KGBD134694',
            'KGBD134695',
            'KGBD134696',
            'KGBD136010',
            'KGBD146607',
            'KGBD166547',
            'KGBD199707',
            'KGBD114653',
            'KGBD114654',
            'KGBD114655',
            'KGBD114656',
            'KGBD114657',
            'KGBD114658',
            'KGBD114659',
            'KGBD114660',
            'KGBD114886',
            'KGBD114887',
            'KGBD114888',
            'KGBD114889',
            'KGBD114890',
            'KGBD114891',
            'KGBD114892',
            'KGBD114893',
            'KGBD114894',
            'KGBD133216',
            'KGBD142997',
            'KGBD142998',
            'KGBD144761',
            'KGBD144763',
            'KGBD229704',
            'KGBD130934',
            'KGBD130940',
            'KGBD192130',
            'KGBD120684',
            'KGBD115052',
            'KGBD115055',
            'KGBD115056',
            'KGBD115057',
            'KGBD115058',
            'KGBD115059',
            'KGBD115061',
            'KGBD118474',
            'KGBD119118',
            'KGBD119142',
            'KGBD148382',
            'KGBD166565',
            'KGBD192108',
            'KGBD192111',
            'KGBD192110',
            'KGBD256483',
            'KGBD117967',
            'KGBD117968',
            'KGBD117969',
            'KGBD117970',
            'KGBD117971',
            'KGBD117972',
            'KGBD117973',
            'KGBD176253',
            'KGBD196771',
            'KGBD196770',
            'KGBD199344',
            'KGBD199345',
            'KGBD203853',
            'KGBD203854',
            'KGBD206861',
            'KGBD229472',
            'KGBD119190',
            'KGBD121029',
            'KGBD121488',
            'KGBD122740',
            'KGBD122746',
            'KGBD122748',
            'KGBD135446',
            'KGBD122745',
            'KGBD122722',
            'KGBD122718',
            'KGBD122717',
            'KGBD122716',
            'KGBD122789',
            'KGBD122788',
            'KGBD133914',
            'KGBD151125',
            'KGBD152913',
            'KGBD123383',
            'KGBD123384',
            'KGBD128818',
            'KGBD129899',
            'KGBD130607',
            'KGBD134400',
            'KGBD129778',
            'KGBD129779',
            'KGBD129780',
            'KGBD129781',
            'KGBD129790',
            'KGBD129789',
            'KGBD129787',
            'KGBD129786',
            'KGBD129785',
            'KGBD129784',
            'KGBD129783',
            'KGBD129782',
            'KGBD142870',
            'KGBD149275',
            'KGBD150922',
            'KGBD150923',
            'KGBD150924',
            'KGBD150926',
            'KGBD133993',
            'KGBD133951',
            'KGBD133956',
            'KGBD134872',
            'KGBD134873',
            'KGBD134874',
            'KGBD134875',
            'KGBD134876',
            'KGBD134998',
            'KGBD138316',
            'KGBD136078',
            'KGBD149372',
            'KGBD135044',
            'KGBD135045',
            'KGBD135046',
            'KGBD135047',
            'KGBD135048',
            'KGBD135049',
            'KGBD135050',
            'KGBD230596',
            'KGBD230595',
            'KGBD136937',
            'KGBD140764',
            'KGBD140765',
            'KGBD140766',
            'KGBD140767',
            'KGBD140768',
            'KGBD140769',
            'KGBD140770',
            'KGBD140771',
            'KGBD140772',
            'KGBD140773',
            'KGBD140774',
            'KGBD140233',
            'KGBD140255',
            'KGBD140260',
            'KGBD140231',
            'KGBD141146',
            'KGBD141208',
            'KGBD140252',
            'KGBD142556',
            'KGBD141211',
            'KGBD142541',
            'KGBD154623',
            'KGBD155770',
            'KGBD155774',
            'KGBD155775',
            'KGBD156207',
            'KGBD156209',
            'KGBD156208',
            'KGBD156210',
            'KGBD158351',
            'KGBD166482',
            'KGBD166483',
            'KGBD166486',
            'KGBD168059',
            'KGBD168060',
            'KGBD168061',
            'KGBD168062',
            'KGBD168063',
            'KGBD168517',
            'KGBD168519',
            'KGBD168520',
            'KGBD169772',
            'KGBD169791',
            'KGBD181641',
            'KGBD192653',
            'KGBD192654',
            'KGBD192655',
            'KGBD192656',
            'KGBD192657',
            'KGBD192658',
            'KGBD192659',
            'KGBD140250',
            'KGBD209411',
            'KGBD209405',
            'KGBD209407',
            'KGBD209414',
            'KGBD209410',
            'KGBD209404',
            'KGBD209413',
            'KGBD209409',
            'KGBD209412',
            'KGBD209408',
            'KGBD209406',
            'KGBD209402',
            'KGBD209403',
            'KGBD209401',
            'KGBD209622',
            'KGBD212753',
            'KGBD212755',
            'KGBD212754',
            'KGBD212756',
            'KGBD212793',
            'KGBD212795',
            'KGBD212796',
            'KGBD212794',
            'KGBD212797',
            'KGBD212798',
            'KGBD220135',
            'KGBD220598',
            'KGBD220600',
            'KGBD220599',
            'KGBD220617',
            'KGBD220616',
            'KGBD220615',
            'KGBD220939',
            'KGBD219743',
            'KGBD228901',
            'KGBD228898',
            'KGBD228900',
            'KGBD219751',
            'KGBD141248',
            'KGBD142872',
            'KGBD142873',
            'KGBD142874',
            'KGBD142875',
            'KGBD142876',
            'KGBD142877',
            'KGBD142878',
            'KGBD144022',
            'KGBD144023',
            'KGBD144755',
            'KGBD144756',
            'KGBD144021',
            'KGBD182623',
            'KGBD182624',
            'KGBD182628',
            'KGBD182626',
            'KGBD182627',
            'KGBD182625',
            'KGBD182630',
            'KGBD182633',
            'KGBD182629',
            'KGBD182632',
            'KGBD182631',
            'KGBD182634',
            'KGBD182635',
            'KGBD182636',
            'KGBD182637',
            'KGBD182638',
            'KGBD182639',
            'KGBD182640',
            'KGBD182641',
            'KGBD182642',
            'KGBD182643',
            'KGBD182644',
            'KGBD191925',
            'KGBD204297',
            'KGBD148298',
            'KGBD148299',
            'KGBD148300',
            'KGBD148301',
            'KGBD148302',
            'KGBD148303',
            'KGBD148304',
            'KGBD148305',
            'KGBD148306',
            'KGBD148307',
            'KGBD148308',
            'KGBD148309',
            'KGBD148310',
            'KGBD148311',
            'KGBD148312',
            'KGBD148313',
            'KGBD148314',
            'KGBD157148',
            'KGBD178933',
            'KGBD149679',
            'KGBD149680',
            'KGBD149609',
            'KGBD218722',
            'KGBD218724',
            'KGBD218727',
            'KGBD218726',
            'KGBD218717',
            'KGBD218725',
            'KGBD218723',
            'KGBD218719',
            'KGBD231525',
            'KGBD231515',
            'KGBD231516',
            'KGBD231524',
            'KGBD231521',
            'KGBD231519',
            'KGBD231514',
            'KGBD231522',
            'KGBD231520',
            'KGBD231523',
            'KGBD231528',
            'KGBD231518',
            'KGBD231526',
            'KGBD231531',
            'KGBD231535',
            'KGBD231527',
            'KGBD231529',
            'KGBD231530',
            'KGBD231483',
            'KGBD231489',
            'KGBD231485',
            'KGBD231484',
            'KGBD231486',
            'KGBD231481',
            'KGBD231490',
            'KGBD231487',
            'KGBD231482',
            'KGBD231493',
            'KGBD231492',
            'KGBD231488',
            'KGBD231549',
            'KGBD231548',
            'KGBD231546',
            'KGBD231547',
            'KGBD231553',
            'KGBD231543',
            'KGBD231550',
            'KGBD231551',
            'KGBD231557',
            'KGBD231556',
            'KGBD231555',
            'KGBD231532',
            'KGBD231552',
            'KGBD231533',
            'KGBD231538',
            'KGBD231536',
            'KGBD231537',
            'KGBD231539',
            'KGBD231534',
            'KGBD231541',
            'KGBD231540',
            'KGBD231545',
            'KGBD231542',
            'KGBD231544',
            'KGBD231491',
            'KGBD231496',
            'KGBD231495',
            'KGBD231499',
            'KGBD231494',
            'KGBD231563',
            'KGBD231562',
            'KGBD231561',
            'KGBD231559',
            'KGBD231560',
            'KGBD231554',
            'KGBD231566',
            'KGBD231565',
            'KGBD231570',
            'KGBD231564',
            'KGBD231569',
            'KGBD231558',
            'KGBD231567',
            'KGBD231574',
            'KGBD231573',
            'KGBD231572',
            'KGBD231571',
            'KGBD231568',
            'KGBD231513',
            'KGBD231508',
            'KGBD231511',
            'KGBD231512',
            'KGBD231517',
            'KGBD231596',
            'KGBD231602',
            'KGBD231603',
            'KGBD231601',
            'KGBD231605',
            'KGBD231597',
            'KGBD231608',
            'KGBD231607',
            'KGBD231606',
            'KGBD231610',
            'KGBD231609',
            'KGBD231497',
            'KGBD231604',
            'KGBD231503',
            'KGBD231502',
            'KGBD231501',
            'KGBD231498',
            'KGBD231500',
            'KGBD231506',
            'KGBD231504',
            'KGBD231505',
            'KGBD231510',
            'KGBD231509',
            'KGBD231507',
            'KGBD231588',
            'KGBD231587',
            'KGBD231592',
            'KGBD231591',
            'KGBD231590',
            'KGBD231589',
            'KGBD231594',
            'KGBD231593',
            'KGBD231598',
            'KGBD231600',
            'KGBD231599',
            'KGBD231595',
            'KGBD231578',
            'KGBD231577',
            'KGBD231576',
            'KGBD231575',
            'KGBD231581',
            'KGBD231579',
            'KGBD231586',
            'KGBD231580',
            'KGBD231585',
            'KGBD231584',
            'KGBD231583',
            'KGBD231582',
            'KGBD149487',
            'KGBD149505',
            'KGBD149506',
            'KGBD149503',
            'KGBD149501',
            'KGBD149497',
            'KGBD149495',
            'KGBD149496',
            'KGBD149504',
            'KGBD149498',
            'KGBD150777',
            'KGBD217934',
            'KGBD151138',
            'KGBD151139',
            'KGBD151140',
            'KGBD151141',
            'KGBD151142',
            'KGBD151143',
            'KGBD151144',
            'KGBD151145',
            'KGBD151146',
            'KGBD151147',
            'KGBD151148',
            'KGBD151149',
            'KGBD151150',
            'KGBD151151',
            'KGBD151152',
            'KGBD151153',
            'KGBD151154',
            'KGBD153122',
            'KGBD153123',
            'KGBD153124',
            'KGBD153125',
            'KGBD153126',
            'KGBD153127',
            'KGBD209226',
            'KGBD215771',
            'KGBD218639',
            'KGBD228590',
            'KGBD179242',
            'KGBD179244',
            'KGBD179245',
            'KGBD179246',
            'KGBD179247',
            'KGBD179248',
            'KGBD179249',
            'KGBD179250',
            'KGBD179256',
            'KGBD185533',
            'KGBD185528',
            'KGBD185531',
            'KGBD185527',
            'KGBD185534',
            'KGBD185535',
            'KGBD192129',
            'KGBD193755',
            'KGBD194779',
            'KGBD195553',
            'KGBD154690',
            'KGBD154691',
            'KGBD154692',
            'KGBD154694',
            'KGBD154695',
            'KGBD154696',
            'KGBD154697',
            'KGBD154698',
            'KGBD154699',
            'KGBD154700',
            'KGBD154701',
            'KGBD241359',
            'KGBD252271',
            'KGBD186186',
            'KGBD186187',
            'KGBD186189',
            'KGBD160526',
            'KGBD160527',
            'KGBD160528',
            'KGBD160529',
            'KGBD160530',
            'KGBD160531',
            'KGBD160532',
            'KGBD160535',
            'KGBD160536',
            'KGBD160557',
            'KGBD186040',
            'KGBD171660',
            'KGBD171083',
            'KGBD172287',
            'KGBD173649',
            'KGBD175069',
            'KGBD178997',
            'KGBD175824',
            'KGBD175825',
            'KGBD175826',
            'KGBD175827',
            'KGBD175828',
            'KGBD175829',
            'KGBD175830',
            'KGBD172299',
            'KGBD172300',
            'KGBD172301',
            'KGBD172302',
            'KGBD172303',
            'KGBD172304',
            'KGBD172291',
            'KGBD172295',
            'KGBD203841',
            'KGBD204663',
            'KGBD171050',
            'KGBD252633',
            'KGBD254393',
            'KGBD174919',
            'KGBD174968',
            'KGBD176243',
            'KGBD178289',
            'KGBD178290',
            'KGBD185259',
            'KGBD186646',
            'KGBD187436',
            'KGBD205427',
            'KGBD185536',
            'KGBD232262',
            'KGBD256395',
            'KGBD172376',
            'KGBD173630',
            'KGBD173631',
            'KGBD173871',
            'KGBD174731',
            'KGBD179207',
            'KGBD179209',
            'KGBD179211',
            'KGBD179214',
            'KGBD179215',
            'KGBD179219',
            'KGBD179220',
            'KGBD179221',
            'KGBD179222',
            'KGBD179208',
            'KGBD179210',
            'KGBD179213',
            'KGBD179218',
            'KGBD179223',
            'KGBD179225',
            'KGBD179226',
            'KGBD202076',
            'KGBD220287',
            'KGBD220288',
            'KGBD220289',
            'KGBD220290',
            'KGBD220291',
            'KGBD220292',
            'KGBD241135',
            'KGBD241134',
            'KGBD257936',
            'KGBD176128',
            'KGBD176129',
            'KGBD176130',
            'KGBD176131',
            'KGBD176132',
            'KGBD176994',
            'KGBD176995',
            'KGBD176996',
            'KGBD176997',
            'KGBD176998',
            'KGBD176999',
            'KGBD177000',
            'KGBD177001',
            'KGBD177002',
            'KGBD177003',
            'KGBD177004',
            'KGBD177005',
            'KGBD177006',
            'KGBD177007',
            'KGBD177008',
            'KGBD177009',
            'KGBD177010',
            'KGBD177546',
            'KGBD177545',
            'KGBD177544',
            'KGBD177543',
            'KGBD182141',
            'KGBD177501',
            'KGBD177911',
            'KGBD177912',
            'KGBD177913',
            'KGBD177914',
            'KGBD177915',
            'KGBD177916',
            'KGBD177917',
            'KGBD177918',
            'KGBD177919',
            'KGBD177920',
            'KGBD177921',
            'KGBD177922',
            'KGBD177923',
            'KGBD180369',
            'KGBD180372',
            'KGBD180377',
            'KGBD180379',
            'KGBD180383',
            'KGBD180384',
            'KGBD180385',
            'KGBD180386',
            'KGBD193514',
            'KGBD194109',
            'KGBD177982',
            'KGBD177983',
            'KGBD177984',
            'KGBD177985',
            'KGBD177986',
            'KGBD177987',
            'KGBD177988',
            'KGBD177989',
            'KGBD178280',
            'KGBD185258',
            'KGBD196199',
            'KGBD202130',
            'KGBD179295',
            'KGBD180441',
            'KGBD180444',
            'KGBD180447',
            'KGBD180450',
            'KGBD180453',
            'KGBD180455',
            'KGBD180457',
            'KGBD180420',
            'KGBD180421',
            'KGBD180422',
            'KGBD180423',
            'KGBD180424',
            'KGBD180425',
            'KGBD180426',
            'KGBD180427',
            'KGBD180428',
            'KGBD180429',
            'KGBD180430',
            'KGBD180431',
            'KGBD180432',
            'KGBD184228',
            'KGBD182480',
            'KGBD181896',
            'KGBD181897',
            'KGBD181898',
            'KGBD225044',
            'KGBD225055',
            'KGBD185799',
            'KGBD185798',
            'KGBD185796',
            'KGBD185794',
            'KGBD185800',
            'KGBD185797',
            'KGBD185791',
            'KGBD185793',
            'KGBD185795',
            'KGBD193821',
            'KGBD193820',
            'KGBD193819',
            'KGBD193818',
            'KGBD199246',
            'KGBD199245',
            'KGBD184979',
            'KGBD184980',
            'KGBD184982',
            'KGBD184983',
            'KGBD184984',
            'KGBD184985',
            'KGBD184986',
            'KGBD184987',
            'KGBD184988',
            'KGBD184989',
            'KGBD184990',
            'KGBD184991',
            'KGBD184992',
            'KGBD184993',
            'KGBD184994',
            'KGBD184981',
            'KGBD184995',
            'KGBD184996',
            'KGBD184997',
            'KGBD238091',
            'KGBD241927',
            'KGBD187602',
            'KGBD185494',
            'KGBD185499',
            'KGBD185496',
            'KGBD185497',
            'KGBD185498',
            'KGBD185500',
            'KGBD185501',
            'KGBD185502',
            'KGBD185503',
            'KGBD185504',
            'KGBD185505',
            'KGBD185506',
            'KGBD185507',
            'KGBD185508',
            'KGBD185510',
            'KGBD185509',
            'KGBD185511',
            'KGBD185512',
            'KGBD185513',
            'KGBD185514',
            'KGBD185515',
            'KGBD185516',
            'KGBD185517',
            'KGBD186292',
            'KGBD186291',
            'KGBD186290',
            'KGBD217522',
            'KGBD199776',
            'KGBD242774',
            'KGBD186728',
            'KGBD186737',
            'KGBD186733',
            'KGBD186735',
            'KGBD186729',
            'KGBD186740',
            'KGBD186734',
            'KGBD186736',
            'KGBD186732',
            'KGBD186731',
            'KGBD186738',
            'KGBD186739',
            'KGBD186730',
            'KGBD186741',
            'KGBD186742',
            'KGBD192589',
            'KGBD186857',
            'KGBD189038',
            'KGBD189039',
            'KGBD189040',
            'KGBD189041',
            'KGBD258104',
            'KGBD258100',
            'KGBD258098',
            'KGBD258097',
            'KGBD258106',
            'KGBD258105',
            'KGBD258103',
            'KGBD258102',
            'KGBD258101',
            'KGBD258099',
            'KGBD258096',
            'KGBD258175',
            'KGBD258176',
            'KGBD187511',
            'KGBD187512',
            'KGBD187513',
            'KGBD187514',
            'KGBD187515',
            'KGBD187516',
            'KGBD187517',
            'KGBD187518',
            'KGBD187519',
            'KGBD188720',
            'KGBD188722',
            'KGBD188723',
            'KGBD188724',
            'KGBD188725',
            'KGBD188726',
            'KGBD188727',
            'KGBD189018',
            'KGBD187508',
            'KGBD223362',
            'KGBD232523',
            'KGBD234277',
            'KGBD242193',
            'KGBD259437',
            'KGBD257541',
            'KGBD258070',
            'KGBD192409',
            'KGBD192408',
            'KGBD192407',
            'KGBD192406',
            'KGBD192405',
            'KGBD192404',
            'KGBD192413',
            'KGBD192412',
            'KGBD192411',
            'KGBD192467',
            'KGBD192466',
            'KGBD192544',
            'KGBD192543',
            'KGBD203244',
            'KGBD203245',
            'KGBD203246',
            'KGBD203247',
            'KGBD203248',
            'KGBD204574',
            'KGBD191018',
            'KGBD191013',
            'KGBD191016',
            'KGBD191012',
            'KGBD191017',
            'KGBD191021',
            'KGBD191019',
            'KGBD191014',
            'KGBD191020',
            'KGBD191024',
            'KGBD191023',
            'KGBD191026',
            'KGBD191022',
            'KGBD191025',
            'KGBD201452',
            'KGBD205625',
            'KGBD189218',
            'KGBD193250',
            'KGBD193252',
            'KGBD193259',
            'KGBD193253',
            'KGBD193255',
            'KGBD193257',
            'KGBD193256',
            'KGBD193258',
            'KGBD193254',
            'KGBD193260',
            'KGBD193261',
            'KGBD193487',
            'KGBD193488',
            'KGBD232884',
            'KGBD232886',
            'KGBD232887',
            'KGBD232889',
            'KGBD232883',
            'KGBD232885',
            'KGBD232888',
            'KGBD232890',
            'KGBD232891',
            'KGBD232908',
            'KGBD194100',
            'KGBD197023',
            'KGBD205561',
            'KGBD253061',
            'KGBD253064',
            'KGBD253065',
            'KGBD254029',
            'KGBD254601',
            'KGBD254634',
            'KGBD254635',
            'KGBD254636',
            'KGBD254638',
            'KGBD254641',
            'KGBD254642',
            'KGBD254643',
            'KGBD254644',
            'KGBD254645',
            'KGBD254646',
            'KGBD193178',
            'KGBD193784',
            'KGBD193857',
            'KGBD193858',
            'KGBD193859',
            'KGBD193860',
            'KGBD193861',
            'KGBD193862',
            'KGBD193863',
            'KGBD193864',
            'KGBD218425',
            'KGBD220349',
            'KGBD194053',
            'KGBD195511',
            'KGBD195519',
            'KGBD195512',
            'KGBD195518',
            'KGBD195515',
            'KGBD195513',
            'KGBD195514',
            'KGBD195516',
            'KGBD195517',
            'KGBD195520',
            'KGBD195521',
            'KGBD195522',
            'KGBD254190',
            'KGBD195573',
            'KGBD195722',
            'KGBD195825',
            'KGBD198127',
            'KGBD222608',
            'KGBD222609',
            'KGBD229952',
            'KGBD258071',
            'KGBD197840',
            'KGBD197837',
            'KGBD197838',
            'KGBD197836',
            'KGBD197839',
            'KGBD197841',
            'KGBD198817',
            'KGBD199478',
            'KGBD199552',
            'KGBD199553',
            'KGBD201697',
            'KGBD204664',
            'KGBD205513',
            'KGBD207812',
            'KGBD219791',
            'KGBD254376',
            'KGBD254430',
            'KGBD254431',
            'KGBD254432',
            'KGBD255838',
            'KGBD255839',
            'KGBD255840',
            'KGBD199231',
            'KGBD208562',
            'KGBD230138',
            'KGBD250171',
            'KGBD250172',
            'KGBD199327',
            'KGBD199331',
            'KGBD211382',
            'KGBD199819',
            'KGBD200029',
            'KGBD209870',
            'KGBD220357',
            'KGBD202074',
            'KGBD202072',
            'KGBD231793',
            'KGBD208493',
            'KGBD203728',
            'KGBD205436',
            'KGBD205437',
            'KGBD205438',
            'KGBD205441',
            'KGBD205443',
            'KGBD198486',
            'KGBD207431',
            'KGBD207430',
            'KGBD207429',
            'KGBD207428',
            'KGBD207427',
            'KGBD207426',
            'KGBD207425',
            'KGBD207424',
            'KGBD207423',
            'KGBD207422',
            'KGBD207421',
            'KGBD207420',
            'KGBD207419',
            'KGBD207418',
            'KGBD207417',
            'KGBD207416',
            'KGBD207415',
            'KGBD207414',
            'KGBD207413',
            'KGBD207412',
            'KGBD207411',
            'KGBD217158',
            'KGBD217157',
            'KGBD217053',
            'KGBD217051',
            'KGBD217050',
            'KGBD217049',
            'KGBD218088',
            'KGBD223054',
            'KGBD243628',
            'KGBD250160',
            'KGBD211596',
            'KGBD211599',
            'KGBD211600',
            'KGBD211595',
            'KGBD211604',
            'KGBD211598',
            'KGBD211597',
            'KGBD211601',
            'KGBD211603',
            'KGBD254850',
            'KGBD209229',
            'KGBD243358',
            'KGBD209417',
            'KGBD209418',
            'KGBD209419',
            'KGBD209420',
            'KGBD209421',
            'KGBD209422',
            'KGBD209423',
            'KGBD209424',
            'KGBD223061',
            'KGBD223060',
            'KGBD223059',
            'KGBD228546',
            'KGBD238092',
            'KGBD218742',
            'KGBD254034',
            'KGBD216261',
            'KGBD216287',
            'KGBD216687',
            'KGBD216693',
            'KGBD216692',
            'KGBD216691',
            'KGBD216690',
            'KGBD216689',
            'KGBD216688',
            'KGBD220487',
            'KGBD218236',
            'KGBD218237',
            'KGBD218238',
            'KGBD218239',
            'KGBD218240',
            'KGBD218241',
            'KGBD218242',
            'KGBD218243',
            'KGBD218244',
            'KGBD218245',
            'KGBD218246',
            'KGBD218247',
            'KGBD218248',
            'KGBD218249',
            'KGBD218252',
            'KGBD218253',
            'KGBD218729',
            'KGBD218730',
            'KGBD218731',
            'KGBD220635',
            'KGBD220636',
            'KGBD220637',
            'KGBD220638',
            'KGBD220639',
            'KGBD220640',
            'KGBD222192',
            'KGBD226127',
            'KGBD232612',
            'KGBD232842',
            'KGBD232843',
            'KGBD232844',
            'KGBD232845',
            'KGBD234273',
            'KGBD234443',
            'KGBD234556',
            'KGBD234557',
            'KGBD238166',
            'KGBD238242',
            'KGBD238243',
            'KGBD238244',
            'KGBD238687',
            'KGBD238685',
            'KGBD238686',
            'KGBD240906',
            'KGBD249354',
            'KGBD249355',
            'KGBD249368',
            'KGBD249370',
            'KGBD249369',
            'KGBD226002',
            'KGBD226001',
            'KGBD226000',
            'KGBD225999',
            'KGBD225998',
            'KGBD225997',
            'KGBD225996',
            'KGBD225995',
            'KGBD226010',
            'KGBD226009',
            'KGBD226008',
            'KGBD226007',
            'KGBD226006',
            'KGBD226005',
            'KGBD226004',
            'KGBD243285',
            'KGBD254146',
            'KGBD251599',
            'KGBD251603',
            'KGBD229060',
            'KGBD229718',
            'KGBD229723',
            'KGBD229717',
            'KGBD229719',
            'KGBD229721',
            'KGBD229722',
            'KGBD229715',
            'KGBD229720',
            'KGBD229714',
            'KGBD229724',
            'KGBD229725',
            'KGBD229728',
            'KGBD229726',
            'KGBD229730',
            'KGBD229732',
            'KGBD229727',
            'KGBD229729',
            'KGBD229742',
            'KGBD229743',
            'KGBD232514',
            'KGBD232517',
            'KGBD232518',
            'KGBD232519',
            'KGBD232520',
            'KGBD232515',
            'KGBD239659',
            'KGBD239653',
            'KGBD239648',
            'KGBD239656',
            'KGBD239651',
            'KGBD239658',
            'KGBD239654',
            'KGBD239657',
            'KGBD239649',
            'KGBD239655',
            'KGBD239652',
            'KGBD239650',
            'KGBD239647',
            'KGBD239646',
            'KGBD243290',
            'KGBD230085',
            'KGBD252261',
            'KGBD233763',
            'KGBD233035',
            'KGBD233034',
            'KGBD233041',
            'KGBD233042',
            'KGBD233036',
            'KGBD233033',
            'KGBD233040',
            'KGBD233038',
            'KGBD233037',
            'KGBD233043',
            'KGBD233044',
            'KGBD233045',
            'KGBD233046',
            'KGBD233047',
            'KGBD233048',
            'KGBD233049',
            'KGBD232870',
            'KGBD235317',
            'KGBD235318',
            'KGBD235316',
            'KGBD235319',
            'KGBD240917',
            'KGBD240925',
            'KGBD240922',
            'KGBD240918',
            'KGBD240921',
            'KGBD240923',
            'KGBD240919',
            'KGBD240916',
            'KGBD240924',
            'KGBD240926',
            'KGBD240928',
            'KGBD240927',
            'KGBD240930',
            'KGBD240929',
            'KGBD241785',
            'KGBD241786',
            'KGBD247636',
            'KGBD247637',
            'KGBD247640',
            'KGBD247642',
            'KGBD247638',
            'KGBD247639',
            'KGBD247634',
            'KGBD247635',
            'KGBD247641',
            'KGBD247644',
            'KGBD247645',
            'KGBD247646',
            'KGBD247643',
            'KGBD249119',
            'KGBD249117',
            'KGBD249176',
            'KGBD249180',
            'KGBD249174',
            'KGBD249178',
            'KGBD249175',
            'KGBD249118',
            'KGBD249179',
            'KGBD249181',
            'KGBD249183',
            'KGBD249182',
            'KGBD249184',
            'KGBD249187',
            'KGBD249185',
            'KGBD249190',
            'KGBD249189',
            'KGBD249186',
            'KGBD249188',
            'KGBD249191',
            'KGBD249192',
            'KGBD249193',
            'KGBD249194',
            'KGBD239580',
            'KGBD239500',
            'KGBD239559',
            'KGBD239558',
            'KGBD239534',
            'KGBD239536',
            'KGBD239581',
            'KGBD239556',
            'KGBD239538',
            'KGBD239502',
            'KGBD239509',
            'KGBD239532',
            'KGBD239582',
            'KGBD239583',
            'KGBD241145',
            'KGBD241147',
            'KGBD242378',
            'KGBD242377',
            'KGBD242379',
            'KGBD242384',
            'KGBD242383',
            'KGBD242382',
            'KGBD242380',
            'KGBD242381',
            'KGBD259082',
            'KGBD259083',
            'KGBD259084',
            'KGBD242314',
            'KGBD241826',
            'KGBD241827',
            'KGBD241833',
            'KGBD241831',
            'KGBD241828',
            'KGBD241825',
            'KGBD241830',
            'KGBD241834',
            'KGBD241832',
            'KGBD241835',
            'KGBD241839',
            'KGBD241837',
            'KGBD241840',
            'KGBD241838',
            'KGBD241836',
            'KGBD248590',
            'KGBD252032',
            'KGBD252033',
            'KGBD248233',
            'KGBD248239',
            'KGBD248244',
            'KGBD248230',
            'KGBD249353',
            'KGBD257547',
            'KGBD258182',
            'KGBD258181',
            'KGBD253554',
            'KGBD253952',
            'KGBD253953',
            'KGBD253955',
            'KGBD256380',
            'KGBD256382',
            'KGBD256383',
            'KGBD256390',
            'KGBD256384',
            'KGBD256385',
            'KGBD256387',
            'KGBD256388',
            'KGBD256389',
            'KGBD254246',
            'KGBD254370',
            'KGBD254375',
            'KGBD254377',
            'KGBD255970',
            'KGBD255972',
            'KGBD255973',
            'KGBD255974',
            'KGBD258194',
            'KGBD259505',
            'KGBD258216',
            'KGBD258210',
            'KGBD258213',
            'KGBD258214',
            'KGBD258211',
            'KGBD258215',
            'KGBD258212',
            'KGBD258207',
            'KGBD258209',
            'KGBD258218',
            'KGBD258217',
            'KGBD259008',
            'KGBD258219',
            'KGBD259009',
            'KGBD258220',
            'KGBD258221',
            'KGBD258222',
            'KGBD258621',
            'KGBD259490',
            'KGBD100042',
            'KGBD120213',
            'KGBD194777',
            'KGBD196745',
            'KGBD099828',
            'KGBD104583',
            'KGBD107950',
            'KGBD107947',
            'KGBD107946',
            'KGBD108264',
            'KGBD109469',
            'KGBD109476',
            'KGBD109475',
            'KGBD109473',
            'KGBD109472',
            'KGBD109621',
            'KGBD109656',
            'KGBD110711',
            'KGBD110724',
            'KGBD134699',
            'KGBD134855',
            'KGBD150879',
            'KGBD106828',
            'KGBD174730',
            'KGBD174734',
            'KGBD117631',
            'KGBD124264',
            'KGBD146629',
            'KGBD181847',
            'KGBD187104',
            'KGBD192313',
            'KGBD253253',
            'KGBD109679',
            'KGBD109681',
            'KGBD110870',
            'KGBD110871',
            'KGBD110922',
            'KGBD110923',
            'KGBD111132',
            'KGBD110847',
            'KGBD110861',
            'KGBD110865',
            'KGBD110866',
            'KGBD115040',
            'KGBD112354',
            'KGBD142838',
            'KGBD151098',
            'KGBD201613',
            'KGBD216962',
            'KGBD112154',
            'KGBD112155',
            'KGBD113579',
            'KGBD113580',
            'KGBD113983',
            'KGBD113583',
            'KGBD113985',
            'KGBD113986',
            'KGBD113987',
            'KGBD114030',
            'KGBD114882',
            'KGBD114903',
            'KGBD123982',
            'KGBD173129',
            'KGBD173136',
            'KGBD134828',
            'KGBD134829',
            'KGBD145402',
            'KGBD146631',
            'KGBD171546',
            'KGBD172835',
            'KGBD173128',
            'KGBD173132',
            'KGBD173133',
            'KGBD173134',
            'KGBD173135',
            'KGBD175764',
            'KGBD180530',
            'KGBD184226',
            'KGBD185539',
            'KGBD188549',
            'KGBD215720',
            'KGBD222115',
            'KGBD115138',
            'KGBD116455',
            'KGBD116454',
            'KGBD116452',
            'KGBD118589',
            'KGBD118591',
            'KGBD119230',
            'KGBD122436',
            'KGBD177644',
            'KGBD115605',
            'KGBD115597',
            'KGBD115593',
            'KGBD115590',
            'KGBD115586',
            'KGBD119119',
            'KGBD120661',
            'KGBD121506',
            'KGBD122759',
            'KGBD130631',
            'KGBD134160',
            'KGBD136016',
            'KGBD136017',
            'KGBD142767',
            'KGBD116451',
            'KGBD117641',
            'KGBD180291',
            'KGBD180292',
            'KGBD180293',
            'KGBD201990',
            'KGBD201991',
            'KGBD201992',
            'KGBD201993',
            'KGBD254989',
            'KGBD120218',
            'KGBD120219',
            'KGBD120551',
            'KGBD123221',
            'KGBD123524',
            'KGBD173009',
            'KGBD192698',
            'KGBD199248',
            'KGBD199721',
            'KGBD202128',
            'KGBD120687',
            'KGBD120985',
            'KGBD122758',
            'KGBD122828',
            'KGBD122829',
            'KGBD128828',
            'KGBD129893',
            'KGBD130602',
            'KGBD130603',
            'KGBD130604',
            'KGBD130608',
            'KGBD129898',
            'KGBD129897',
            'KGBD129896',
            'KGBD129895',
            'KGBD130605',
            'KGBD130606',
            'KGBD133353',
            'KGBD133352',
            'KGBD134419',
            'KGBD134420',
            'KGBD134701',
            'KGBD136742',
            'KGBD139455',
            'KGBD139895',
            'KGBD133946',
            'KGBD133947',
            'KGBD133959',
            'KGBD133960',
            'KGBD145005',
            'KGBD133952',
            'KGBD133957',
            'KGBD146613',
            'KGBD151097',
            'KGBD179227',
            'KGBD000665',
            'KGBD205010',
            'KGBD139606',
            'KGBD139607',
            'KGBD139608',
            'KGBD192378',
            'KGBD201608',
            'KGBD256236',
            'KGBD142573',
            'KGBD199298',
            'KGBD214913',
            'KGBD214912',
            'KGBD142871',
            'KGBD143030',
            'KGBD143031',
            'KGBD143032',
            'KGBD143033',
            'KGBD143034',
            'KGBD143037',
            'KGBD143036',
            'KGBD143038',
            'KGBD143039',
            'KGBD143040',
            'KGBD143042',
            'KGBD143043',
            'KGBD143050',
            'KGBD143045',
            'KGBD143046',
            'KGBD143047',
            'KGBD143048',
            'KGBD151745',
            'KGBD145416',
            'KGBD147436',
            'KGBD166575',
            'KGBD149681',
            'KGBD149751',
            'KGBD149753',
            'KGBD151156',
            'KGBD151134',
            'KGBD151135',
            'KGBD151136',
            'KGBD201606',
            'KGBD150795',
            'KGBD151158',
            'KGBD189012',
            'KGBD195552',
            'KGBD245280',
            'KGBD249711',
            'KGBD250173',
            'KGBD250174',
            'KGBD151744',
            'KGBD003892',
            'KGBD003941',
            'KGBD003942',
            'KGBD003949',
            'KGBD003951',
            'KGBD003952',
            'KGBD030915',
            'KGBD152400',
            'KGBD152401',
            'KGBD154693',
            'KGBD182388',
            'KGBD175233',
            'KGBD181573',
            'KGBD182037',
            'KGBD182038',
            'KGBD182048',
            'KGBD182049',
            'KGBD182391',
            'KGBD182447',
            'KGBD182448',
            'KGBD182450',
            'KGBD182449',
            'KGBD182451',
            'KGBD196772',
            'KGBD206889',
            'KGBD182389',
            'KGBD182390',
            'KGBD229748',
            'KGBD229793',
            'KGBD230598',
            'KGBD187717',
            'KGBD172311',
            'KGBD174975',
            'KGBD176254',
            'KGBD181895',
            'KGBD181893',
            'KGBD181894',
            'KGBD185537',
            'KGBD185538',
            'KGBD185529',
            'KGBD185532',
            'KGBD185530',
            'KGBD185526',
            'KGBD185790',
            'KGBD192314',
            'KGBD192587',
            'KGBD186660',
            'KGBD186849',
            'KGBD186855',
            'KGBD186848',
            'KGBD186850',
            'KGBD186856',
            'KGBD186854',
            'KGBD186851',
            'KGBD186853',
            'KGBD186862',
            'KGBD186864',
            'KGBD186649',
            'KGBD186650',
            'KGBD203870',
            'KGBD186647',
            'KGBD189016',
            'KGBD189011',
            'KGBD187440',
            'KGBD187439',
            'KGBD187434',
            'KGBD187716',
            'KGBD187715',
            'KGBD187714',
            'KGBD187713',
            'KGBD193152',
            'KGBD193151',
            'KGBD193150',
            'KGBD193149',
            'KGBD193148',
            'KGBD193346',
            'KGBD193855',
            'KGBD193856',
            'KGBD194099',
            'KGBD195530',
            'KGBD195531',
            'KGBD189547',
            'KGBD189548',
            'KGBD189549',
            'KGBD189550',
            'KGBD192371',
            'KGBD240109',
            'KGBD193489',
            'KGBD193490',
            'KGBD193491',
            'KGBD205633',
            'KGBD232233',
            'KGBD232237',
            'KGBD232234',
            'KGBD232247',
            'KGBD232235',
            'KGBD232243',
            'KGBD232238',
            'KGBD232236',
            'KGBD232246',
            'KGBD232241',
            'KGBD196536',
            'KGBD197843',
            'KGBD203773',
            'KGBD204140',
            'KGBD204662',
            'KGBD211291',
            'KGBD211292',
            'KGBD211293',
            'KGBD211294',
            'KGBD211298',
            'KGBD216622',
            'KGBD226233',
            'KGBD226232',
            'KGBD226230',
            'KGBD226229',
            'KGBD244632',
            'KGBD250124',
            'KGBD254196',
            'KGBD211234',
            'KGBD216607',
            'KGBD193682',
            'KGBD195844',
            'KGBD197036',
            'KGBD199441',
            'KGBD199787',
            'KGBD200028',
            'KGBD202326',
            'KGBD203729',
            'KGBD203730',
            'KGBD203731',
            'KGBD203732',
            'KGBD203733',
            'KGBD203871',
            'KGBD203872',
            'KGBD205007',
            'KGBD205512',
            'KGBD208670',
            'KGBD209359',
            'KGBD193792',
            'KGBD196201',
            'KGBD197844',
            'KGBD198123',
            'KGBD199232',
            'KGBD199233',
            'KGBD199234',
            'KGBD199235',
            'KGBD199237',
            'KGBD199449',
            'KGBD205022',
            'KGBD199236',
            'KGBD205629',
            'KGBD233086',
            'KGBD244572',
            'KGBD247071',
            'KGBD254269',
            'KGBD193817',
            'KGBD194098',
            'KGBD199778',
            'KGBD195723',
            'KGBD196182',
            'KGBD195629',
            'KGBD195630',
            'KGBD256408',
            'KGBD195673',
            'KGBD195674',
            'KGBD196204',
            'KGBD198524',
            'KGBD208554',
            'KGBD216072',
            'KGBD196918',
            'KGBD198526',
            'KGBD198528',
            'KGBD199186',
            'KGBD199290',
            'KGBD199732',
            'KGBD201454',
            'KGBD201700',
            'KGBD206864',
            'KGBD234276',
            'KGBD241817',
            'KGBD197833',
            'KGBD197106',
            'KGBD197834',
            'KGBD197835',
            'KGBD199342',
            'KGBD199343',
            'KGBD216714',
            'KGBD216955',
            'KGBD225750',
            'KGBD199691',
            'KGBD199761',
            'KGBD199762',
            'KGBD199763',
            'KGBD208302',
            'KGBD199765',
            'KGBD199767',
            'KGBD201703',
            'KGBD245225',
            'KGBD245226',
            'KGBD245248',
            'KGBD245249',
            'KGBD245250',
            'KGBD245251',
            'KGBD245252',
            'KGBD245253',
            'KGBD245254',
            'KGBD254268',
            'KGBD254294',
            'KGBD203328',
            'KGBD255610',
            'KGBD255816',
            'KGBD255818',
            'KGBD227743',
            'KGBD203855',
            'KGBD205024',
            'KGBD205023',
            'KGBD205419',
            'KGBD205423',
            'KGBD205425',
            'KGBD205426',
            'KGBD205514',
            'KGBD205709',
            'KGBD205710',
            'KGBD205711',
            'KGBD205712',
            'KGBD205713',
            'KGBD205714',
            'KGBD205715',
            'KGBD205716',
            'KGBD220680',
            'KGBD241363',
            'KGBD251617',
            'KGBD223356',
            'KGBD205705',
            'KGBD205706',
            'KGBD220678',
            'KGBD233827',
            'KGBD205680',
            'KGBD226202',
            'KGBD228001',
            'KGBD207259',
            'KGBD244569',
            'KGBD244570',
            'KGBD244571',
            'KGBD254713',
            'KGBD208563',
            'KGBD213193',
            'KGBD226016',
            'KGBD226023',
            'KGBD226024',
            'KGBD209210',
            'KGBD214632',
            'KGBD214633',
            'KGBD216592',
            'KGBD218495',
            'KGBD219727',
            'KGBD228467',
            'KGBD228468',
            'KGBD228472',
            'KGBD228449',
            'KGBD244573',
            'KGBD244576',
            'KGBD244577',
            'KGBD244575',
            'KGBD249487',
            'KGBD249489',
            'KGBD249490',
            'KGBD210104',
            'KGBD226013',
            'KGBD226017',
            'KGBD211295',
            'KGBD211296',
            'KGBD211297',
            'KGBD214911',
            'KGBD215772',
            'KGBD216060',
            'KGBD216953',
            'KGBD217941',
            'KGBD225747',
            'KGBD226018',
            'KGBD226019',
            'KGBD226252',
            'KGBD226251',
            'KGBD226250',
            'KGBD226249',
            'KGBD226240',
            'KGBD226239',
            'KGBD226238',
            'KGBD226237',
            'KGBD226236',
            'KGBD226235',
            'KGBD226234',
            'KGBD232266',
            'KGBD243289',
            'KGBD249470',
            'KGBD250237',
            'KGBD254429',
            'KGBD255966',
            'KGBD223353',
            'KGBD228474',
            'KGBD228929',
            'KGBD230461',
            'KGBD232856',
            'KGBD225751',
            'KGBD225752',
            'KGBD225753',
            'KGBD040624',
            'KGBD040638',
            'KGBD043283',
            'KGBD227889',
            'KGBD232969',
            'KGBD227979',
            'KGBD254354',
            'KGBD254356',
            'KGBD254349',
            'KGBD254350',
            'KGBD254351',
            'KGBD254347',
            'KGBD254352',
            'KGBD254346',
            'KGBD254348',
            'KGBD254359',
            'KGBD256485',
            'KGBD230566',
            'KGBD231692',
            'KGBD231693',
            'KGBD231695',
            'KGBD250842',
            'KGBD251510',
            'KGBD251527',
            'KGBD251528',
            'KGBD251532',
            'KGBD251550',
            'KGBD251554',
            'KGBD251578',
            'KGBD251579',
            'KGBD251580',
            'KGBD251586',
            'KGBD251589',
            'KGBD251590',
            'KGBD251592',
            'KGBD253169',
            'KGBD254028',
            'KGBD254030',
            'KGBD256478',
            'KGBD256475',
            'KGBD258180',
            'KGBD231697',
            'KGBD254676',
            'KGBD228618',
            'KGBD228619',
            'KGBD228621',
            'KGBD228623',
            'KGBD228625',
            'KGBD228626',
            'KGBD228627',
            'KGBD228687',
            'KGBD229746',
            'KGBD251596',
            'KGBD251597',
            'KGBD253681',
            'KGBD230083',
            'KGBD230082',
            'KGBD229956',
            'KGBD229955',
            'KGBD229954',
            'KGBD229953',
            'KGBD230121',
            'KGBD257997',
            'KGBD258108',
            'KGBD230077',
            'KGBD230564',
            'KGBD042158',
            'KGBD234274',
            'KGBD245100',
            'KGBD253171',
            'KGBD256561',
            'KGBD236661',
            'KGBD236662',
            'KGBD236663',
            'KGBD236666',
            'KGBD236665',
            'KGBD244553',
            'KGBD248226',
            'KGBD248661',
            'KGBD248662',
            'KGBD248671',
            'KGBD242073',
            'KGBD242075',
            'KGBD072088',
            'KGBD082010',
            'KGBD084224',
            'KGBD242149',
            'KGBD243281',
            'KGBD243280',
            'KGBD245062',
            'KGBD245063',
            'KGBD245064',
            'KGBD245061',
            'KGBD245837',
            'KGBD247500',
            'KGBD247501',
            'KGBD248591',
            'KGBD254052',
            'KGBD244562',
            'KGBD247610',
            'KGBD247611',
            'KGBD247502',
            'KGBD247503',
            'KGBD247504',
            'KGBD247505',
            'KGBD247506',
            'KGBD247556',
            'KGBD247557',
            'KGBD247558',
            'KGBD247561',
            'KGBD247564',
            'KGBD247569',
            'KGBD247570',
            'KGBD247571',
            'KGBD247568',
            'KGBD247566',
            'KGBD247565',
            'KGBD247567',
            'KGBD247581',
            'KGBD250816',
            'KGBD250818',
            'KGBD250828',
            'KGBD250838',
            'KGBD250951',
            'KGBD250964',
            'KGBD250958',
            'KGBD248592',
            'KGBD248601',
            'KGBD251593',
            'KGBD251594',
            'KGBD251595',
            'KGBD250251',
            'KGBD257548',
            'KGBD250472',
            'KGBD250788',
            'KGBD251591',
            'KGBD251607',
            'KGBD253800',
            'KGBD251608',
            'KGBD251609',
            'KGBD251611',
            'KGBD251612',
            'KGBD251697',
            'KGBD252555',
            'KGBD253956',
            'KGBD252580',
            'KGBD252581',
            'KGBD252582',
            'KGBD258072',
            'KGBD258073',
            'KGBD258074',
            'KGBD258075',
            'KGBD258076',
            'KGBD258077',
            'KGBD258078',
            'KGBD258111',
            'KGBD258112',
            'KGBD253172',
            'KGBD254153',
            'KGBD253457',
            'KGBD253947',
            'KGBD253948',
            'KGBD254210',
            'KGBD254211',
            'KGBD254434',
            'KGBD254435',
            'KGBD254436',
            'KGBD254463',
            'KGBD254464',
            'KGBD254465',
            'KGBD254462',
            'KGBD256270',
            'KGBD254272',
            'KGBD254270',
            'KGBD254273',
            'KGBD254274',
            'KGBD254275',
            'KGBD254280',
            'KGBD254281',
            'KGBD254282',
            'KGBD066373',
            'KGBD066806',
            'KGBD255975',
            'KGBD256231',
            'KGBD254836',
            'KGBD256557',
            'KGBD256224',
            'KGBD256482',
            'KGBD257071',
            'KGBD257544',
            'KGBD257545',
            'KGBD257546',
            'KGBD258030',
            'KGBD258031',
            'KGBD258034',
            'KGBD258035',
            'KGBD256473',
            'KGBD257069',
            'KGBD258033',
            'KGBD258032',
            'KGBD258089',
            'KGBD256749',
            'KGBD258109',
            'KGBD259088',
            'KGBD072585',
            'KGBD075199',
            'KGBD075200',
            'KGBD075201',
            'KGBD075202',
            'KGBD075203',
            'KGBD075204',
            'KGBD075205',
            'KGBD075206',
            'KGBD075207',
            'KGBD075209',
            'KGBD075208',
            'KGBD075210',
            'KGBD076502',
            'KGBD078216',
            'KGBD079208',
            'KGBD103019',
            'KGBD115070',
            'KGBD117864',
            'KGBD117862',
            'KGBD121630',
            'KGBD080928',
            'KGBD080929',
            'KGBD080930',
            'KGBD082815',
            'KGBD084536',
            'KGBD084546',
            'KGBD089381',
            'KGBD094083',
            'KGBD110566',
            'KGBD110728',
            'KGBD086971',
            'KGBD086972',
            'KGBD086973',
            'KGBD085891',
            'KGBD101243',
            'KGBD102019',
            'KGBD104197',
            'KGBD118484',
            'KGBD158345',
            'KGBD184211',
            'KGBD187110',
            'KGBD190740',
            'KGBD190741',
            'KGBD086521',
            'KGBD086633',
            'KGBD088542',
            'KGBD088543',
            'KGBD088530',
            'KGBD089382',
            'KGBD092269',
            'KGBD211620',
            'KGBD093071',
            'KGBD093073',
            'KGBD093083',
            'KGBD093085',
            'KGBD095650',
            'KGBD095651',
            'KGBD095652',
            'KGBD095653',
            'KGBD091700',
            'KGBD092905',
            'KGBD092906',
            'KGBD092939',
            'KGBD092942',
            'KGBD092943',
            'KGBD092944',
            'KGBD092945',
            'KGBD092946',
            'KGBD092947',
            'KGBD092948',
            'KGBD093084',
            'KGBD092964',
            'KGBD098489',
            'KGBD107820',
            'KGBD142535',
            'KGBD181643',
            'KGBD194078',
            'KGBD195721',
            'KGBD094408',
            'KGBD094410',
            'KGBD094111',
            'KGBD094112',
            'KGBD094113',
            'KGBD094115',
            'KGBD094120',
            'KGBD094121',
            'KGBD094122',
            'KGBD094123',
            'KGBD094124',
            'KGBD094143',
            'KGBD094144',
            'KGBD094375',
            'KGBD094376',
            'KGBD094377',
            'KGBD097500',
            'KGBD097502',
            'KGBD100749',
            'KGBD100747',
            'KGBD100751',
            'KGBD109071',
            'KGBD109072',
            'KGBD110639',
            'KGBD110710',
            'KGBD110636',
            'KGBD110635',
            'KGBD111153',
            'KGBD194113',
            'KGBD209888',
            'KGBD125501',
            'KGBD114913',
            'KGBD133915',
            'KGBD133916',
            'KGBD133917',
            'KGBD133918',
            'KGBD136368',
            'KGBD107878',
            'KGBD120682',
            'KGBD096669',
            'KGBD099188',
            'KGBD099339',
            'KGBD099340',
            'KGBD099341',
            'KGBD114961',
            'KGBD102217',
            'KGBD112169',
            'KGBD119767',
            'KGBD096765',
            'KGBD096766',
            'KGBD206743',
            'KGBD098036',
            'KGBD098500',
            'KGBD099289',
            'KGBD099290',
            'KGBD099291',
            'KGBD099292',
            'KGBD099293',
            'KGBD099294',
            'KGBD099295',
            'KGBD099296',
            'KGBD099297',
            'KGBD099298',
            'KGBD108276',
            'KGBD109682',
            'KGBD109683',
            'KGBD109684',
            'KGBD003431',
            'KGBD013215',
            'KGBD013216',
            'KGBD013217',
            'KGBD013218',
            'KGBD013219',
            'KGBD013220',
            'KGBD015705',
            'KGBD015704',
            'KGBD024191',
            'KGBD024626',
            'KGBD024628',
            'KGBD024617',
            'KGBD024630',
            'KGBD024632',
            'KGBD024634',
            'KGBD024639',
            'KGBD024643',
            'KGBD024650',
            'KGBD024653',
            'KGBD024656',
            'KGBD024659',
            'KGBD024671',
            'KGBD024676',
            'KGBD024729',
            'KGBD001296',
            'KGBD001367',
            'KGBD001368',
            'KGBD002195',
            'KGBD002196',
            'KGBD002197',
            'KGBD002198',
            'KGBD002199',
            'KGBD002200',
            'KGBD002201',
            'KGBD002202',
            'KGBD002306',
            'KGBD002305',
            'KGBD002304',
            'KGBD002303',
            'KGBD002302',
            'KGBD002301',
            'KGBD002650',
            'KGBD002651',
            'KGBD002652',
            'KGBD002653',
            'KGBD002655',
            'KGBD002656',
            'KGBD006751',
            'KGBD010398',
            'KGBD013373',
            'KGBD014594',
            'KGBD017339',
            'KGBD017399',
            'KGBD017400',
            'KGBD018163',
            'KGBD025965',
            'KGBD025967',
            'KGBD025968',
            'KGBD026054',
            'KGBD026055',
            'KGBD026056',
            'KGBD026103',
            'KGBD026204',
            'KGBD029646',
            'KGBD029742',
            'KGBD063188',
            'KGBD004853',
            'KGBD004852',
            'KGBD004851',
            'KGBD004857',
            'KGBD004862',
            'KGBD004861',
            'KGBD004860',
            'KGBD006322',
            'KGBD006352',
            'KGBD006353',
            'KGBD006354',
            'KGBD006351',
            'KGBD006541',
            'KGBD006642',
            'KGBD006643',
            'KGBD006644',
            'KGBD006676',
            'KGBD006675',
            'KGBD006674',
            'KGBD006754',
            'KGBD006755',
            'KGBD006781',
            'KGBD006845',
            'KGBD011236',
            'KGBD039428',
            'KGBD041130',
            'KGBD054318',
            'KGBD011263',
            'KGB003710',
            'KGB003711',
            'KGBD014178',
            'KGBD014182',
            'KGBD014183',
            'KGBD014184',
            'KGBD014185',
            'KGBD014186',
            'KGBD014187',
            'KGBD014188',
            'KGBD014190',
            'KGBD056439',
            'KGBD083835',
            'KGBD083836',
            'KGBD083837',
            'KGBD084323',
            'KGBD085281',
            'KGBD108261',
            'KGBD155756',
            'KGBD171528',
            'KGBD171527',
            'KGBD171526',
            'KGBD171525',
            'KGBD171524',
            'KGBD171523',
            'KGBD173124',
            'KGBD173123',
            'KGBD059486',
            'KGBD059487',
            'KGBD059488',
            'KGBD059489',
            'KGBD059490',
            'KGBD059491',
            'KGBD059492',
            'KGBD059493',
            'KGBD059494',
            'KGBD059495',
            'KGBD060420',
            'KGBD060431',
            'KGBD060427',
            'KGBD060430',
            'KGBD060421',
            'KGBD060424',
            'KGBD064530',
            'KGBD064525',
            'KGBD064524',
            'KGBD064522',
            'KGBD111645',
            'KGBD111598',
            'KGBD059617',
            'KGBD059623',
            'KGBD059635',
            'KGBD059608',
            'KGBD059638',
            'KGBD059639',
            'KGBD000046',
            'KGBD000047',
            'KGBD000049',
            'KGBD000050',
            'KGBD000057',
            'KGBD000149',
            'KGBD000151',
            'KGBD000607',
            'KGBD001750',
            'KGBD001751',
            'KGBD002017',
            'KGBD002083',
            'KGBD002093',
            'KGBD002107',
            'KGBD002108',
            'KGBD002113',
            'KGBD002120',
            'KGBD006574',
            'KGBD059627',
            'KGBD059628',
            'KGBD059629',
            'KGBD059630',
            'KGBD059631',
            'KGBD059633',
            'KGBD232855',
            'KGBD059632',
            'KGBD059634',
            'KGBD072059',
            'KGBD059640',
            'KGBD059642',
            'KGBD059643',
            'KGBD059636',
            'KGBD059637',
            'KGB001778',
            'KGB001779',
            'KGB001780',
            'KGB001781',
            'KGB001784',
            'KGB001785',
            'KGB001799',
            'KGB001800',
            'KGB001801',
            'KGB000977',
            'KGB001791',
            'KGB001796',
            'KGBD101168',
            'KGBD107791',
            'KGBD108013',
            'KGBD108016',
            'KGBD040568',
            'KGBD144903',
            'KGBD144904',
            'KGBD123226',
            'KGBD123381',
            'KGBD151828',
            'KGBD140228',
            'KGBD140229',
            'KGBD140230',
            'KGBD140262',
            'KGBD140263',
            'KGBD140264',
            'KGBD205703',
            'KGBD142331',
            'KGBD174482',
            'KGBD023561',
            'KGBD023880',
            'KGBD023881',
            'KGBD023882',
            'KGBD023883',
            'KGBD023884',
            'KGBD023885',
            'KGBD023890',
            'KGBD023892',
            'KGBD023893',
            'KGBD199451',
            'KGBD000767',
            'KGBD000768',
            'KGBD236890',
            'KGBD214677',
            'KGBD219735',
            'KGB001388',
            'KGB003268',
            'KGB003269',
            'KGB003270',
            'KGB003271',
            'KGB003557',
            'KGB003558',
            'KGB003563',
            'KGB003595',
            'KGBD000606',
            'KGBD000794',
            'KGBD002862',
            'KGBD002863',
            'KGBD002864',
            'KGBD002865',
            'KGBD002866',
            'KGBD002874',
            'KGBD002867',
            'KGBD002868',
            'KGBD002869',
            'KGBD002871',
            'KGBD002882',
            'KGBD007939',
            'KGBD244699',
            'KGBD244700',
            'KGBD006892',
            'KGBD006893',
            'KGBD000242',
            'KGBD000245',
            'KGBD000771',
            'KGB001631',
            'KGB001632',
            'KGB001633',
            'KGB001634',
            'KGB008221',
            'KGBD059293',
            'KGBD000803',
            'KGB000876',
            'KGB000877',
            'KGB000883',
            'KGBD000136',
            'KGBD000137',
            'KGBD000138',
            'KGBD000247',
            'KGBD000251',
            'KGBD003655',
            'KGBD009171',
            'KGBD009172',
            'KGBD000762',
            'KGBD001396',
            'KGBD004715',
            'KGBD005328',
            'KGBD005329',
            'KGBD015874',
            'KGBD015880',
            'KGB006730',
            'KGB014263',
            'KGB004567',
            'KGB004568',
            'KGB004569',
            'KGB004570',
            'KGB004571',
            'KGB004572',
            'KGB004573',
            'KGBD001146',
            'KGBD004707',
            'KGBD004708',
            'KGBD004709',
            'KGBD004710',
            'KGBD037536',
            'KGBD037539',
            'KGBD007911',
            'KGBD000206',
            'KGBD000210',
            'KGBD000283',
            'KGBD000284',
            'KGBD000584',
            'KGBD001165',
            'KGBD002551',
            'KGBD000249',
            'KGBD002665',
            'KGBD005036',
            'KGBD005043',
            'KGBD005048',
            'KGBD005049',
            'KGBD007158',
            'KGBD007159',
            'KGBD009139',
            'KGBD010547',
            'KGBD013749',
            'KGBD072202',
            'KGBD072203',
            'KGBD000571',
            'KGBD005082',
            'KGBD005071',
            'KGBD005072',
            'KGBD005162',
            'KGBD005164',
            'KGBD005166',
            'KGBD005163',
            'KGBD005167',
            'KGBD005168',
            'KGBD005169',
            'KGBD005084',
            'KGBD041333',
            'KGBD013876',
            'KGBD013877',
            'KGBD013878',
            'KGBD013879',
            'KGBD013887',
            'KGBD013888',
            'KGBD014981',
            'KGBD063110',
            'KGBD065323',
            'KGBD036215',
            'KGBD036212',
            'KGBD036209',
            'KGBD036208',
            'KGBD053822',
            'KGBD066826',
            'KGBD066828',
            'KGBD072095',
            'KGBD072096',
            'KGBD102840',
            'KGBD229169',
            'KGB001380',
            'KGBD001484',
            'KGBD006241',
            'KGBD007003',
            'KGBD007004',
            'KGBD008563'
        ];
    }
    
    /**
     * 获取spu
     */
    public function getOtherSpuInfo()
    {
        return [
            '1',
            '71',
            '150',
            '159',
            '190',
            '315',
            '338',
            '342',
            '344',
            '348',
            '350',
            '429',
            '432',
            '580',
            '587',
            '602',
            '1231',
            '1480',
            '2255',
            '2264',
            '2676',
            '2808',
            '3491',
            '3889',
            '4287',
            '4436',
            '4438',
            '4440',
            '4571',
            '5010',
            '5236',
            '5244',
            '5370',
            '5374',
            '5375',
            '5380',
            '5812',
            '5826',
            '6150',
            '6152',
            '6379',
            '6517',
            '6610',
            '7155',
            '7166',
            '7186',
            '7552',
            '7560',
            '7564',
            '7565',
            '7569',
            '7571',
            '7581',
            '7603',
            '7646',
            '7979',
            '8287',
            '8344',
            '8352',
            '8416',
            '8569',
            '8570',
            '8572',
            '8575',
            '8593',
            '8611',
            '8613',
            '8618',
            '8619',
            '8622',
            '8753',
            '8987',
            '9034',
            '9232',
            '9447',
            '9948',
            '9949',
            '10019',
            '10085',
            '10226',
            '10227',
            '10693',
            '10694',
            '11794',
            '11809',
            '11823',
            '11830',
            '11832',
            '11839',
            '11841',
            '11859',
            '11985',
            '12120',
            '12123',
            '12125',
            '12126',
            '12129',
            '12298',
            '12353',
            '13261',
            '13512',
            '13513',
            '14890',
            '15596',
            '17564',
            '17573',
            '17793',
            '18648',
            '18672',
            '18675',
            '18682',
            '18705',
            '18737',
            '18738',
            '18740',
            '18753',
            '18758',
            '18804',
            '18807',
            '18810',
            '18814',
            '18817',
            '18820',
            '18826',
            '18828',
            '18940',
            '19355',
            '19360',
            '19363',
            '19378',
            '19387',
            '19423',
            '19424',
            '19427',
            '19429',
            '19434',
            '19496',
            '19497',
            '20511',
            '20526',
            '20531',
            '20533',
            '20617',
            '20693',
            '20695',
            '20697',
            '20733',
            '20766',
            '20771',
            '20867',
            '20900',
            '20901',
            '20902',
            '20903',
            '20904',
            '20906',
            '20908',
            '20909',
            '20910',
            '20911',
            '20948',
            '20950',
            '20951',
            '20965',
            '20994',
            '21013',
            '21046',
            '21047',
            '21051',
            '21076',
            '21139',
            '21190',
            '21216',
            '21218',
            '21219',
            '21220',
            '21222',
            '21223',
            '21237',
            '21244',
            '21245',
            '21252',
            '21340',
            '21341',
            '21342',
            '21343',
            '21344',
            '21348',
            '21397',
            '21399',
            '21400',
            '21404',
            '21405',
            '21491',
            '21497',
            '21498',
            '21499',
            '21500',
            '21504',
            '21618',
            '21622',
            '21837',
            '21901',
            '21978',
            '22049',
            '22061',
            '22096',
            '22130',
            '22140',
            '22142',
            '22143',
            '22381',
            '22382',
            '22383',
            '22385',
            '22386',
            '22389',
            '22393',
            '22443',
            '22444',
            '22618',
            '22663',
            '22668',
            '22673',
            '22675',
            '22696',
            '22698',
            '22699',
            '22700',
            '22701',
            '22712',
            '22714',
            '22721',
            '22722',
            '22727',
            '22951',
            '22952',
            '22953',
            '23004',
            '23006',
            '23007',
            '23443',
            '23523',
            '23524',
            '23564',
            '23565',
            '23567',
            '23688',
            '23726',
            '23824',
            '23826',
            '23827',
            '23855',
            '23861',
            '23863',
            '23869',
            '23940',
            '23999',
            '24008',
            '24009',
            '24138',
            '24331',
            '24372',
            '24567',
            '24568',
            '24569',
            '24571',
            '24654',
            '24702',
            '24782',
            '25290',
            '25384',
            '25676',
            '25680',
            '25938',
            '25944',
            '26160',
            '26225',
            '26228',
            '26235',
            '26236',
            '26237',
            '26238',
            '26241',
            '26342',
            '26344',
            '26395',
            '26397',
            '26398',
            '26399',
            '26402',
            '26419',
            '26422',
            '26425',
            '26480',
            '26484',
            '26487',
            '26488',
            '26490',
            '26491',
            '26497',
            '26499',
            '26514',
            '26518',
            '26527',
            '26528',
            '26640',
            '26778',
            '27005',
            '27307',
            '27507',
            '27587',
            '27800',
            '27994',
            '28407',
            '28513',
            '28627',
            '28656',
            '28657',
            '28658',
            '28659',
            '29158',
            '29189',
            '29352',
            '29484',
            '29830',
            '29862',
            '29876',
            '29931',
            '30854',
            '30887',
            '30982',
            '31136',
            '31307',
            '31326',
            '31402',
            '32317',
            '32328',
            '32336',
            '32337',
            '32338',
            '32342',
            '32343',
            '32347',
            '32348',
            '32349',
            '32352',
            '32353',
            '32355',
            '32357',
            '32358',
            '32359',
            '32370',
            '32373',
            '32378',
            '32404',
            '32526',
            '32537',
            '32538',
            '32539',
            '32541',
            '32551',
            '32553',
            '32565',
            '32566',
            '32567',
            '32570',
            '32662',
            '32673',
            '32891',
            '32923',
            '32929',
            '32939',
            '32940',
            '32971',
            '33427',
            '33471',
            '33484',
            '33487',
            '33493',
            '33524',
            '33525',
            '33533',
            '33534',
            '33553',
            '33611',
            '33749',
            '33845',
            '33846',
            '33950',
            '33951',
            '33983',
            '34193',
            '34247',
            '34251',
            '34254',
            '34259',
            '34262',
            '34268',
            '34269',
            '34274',
            '34281',
            '34283',
            '34432',
            '34469',
            '34470',
            '34536',
            '34727',
            '34837',
            '34839',
            '34845',
            '34847',
            '34863',
            '34866',
            '34913',
            '35039',
            '35051',
            '35213',
            '35219',
            '35232',
            '35275',
            '35287',
            '35295',
            '35297',
            '35401',
            '35531',
            '35532',
            '35533',
            '35534',
            '35535',
            '35536',
            '35617',
            '35757',
            '35758',
            '35850',
            '35856',
            '35869',
            '35870',
            '35871',
            '35874',
            '35909',
            '35915',
            '35974',
            '36218',
            '36371',
            '36572',
            '36573',
            '36635',
            '36639',
            '36646',
            '36681',
            '36683',
            '36887',
            '37057',
            '37187',
            '37363',
            '37483',
            '37485',
            '37486',
            '37488',
            '37493',
            '37497',
            '37502',
            '37504',
            '37506',
            '37508',
            '37509',
            '37511',
            '37513',
            '37517',
            '37541',
            '37542',
            '37544',
            '37573',
            '37648',
            '38243',
            '38245',
            '38247',
            '38285',
            '38354',
            '38402',
            '38495',
            '38496',
            '38507',
            '38508',
            '38511',
            '38602',
            '38739',
            '38835',
            '38853',
            '38989',
            '39352',
            '39353',
            '39354',
            '39355',
            '39358',
            '39359',
            '39360',
            '39361',
            '39362',
            '39363',
            '39364',
            '39365',
            '39366',
            '39367',
            '39368',
            '39422',
            '39557',
            '39662',
            '39673',
            '39674',
            '39675',
            '39676',
            '39677',
            '39679',
            '39681',
            '39682',
            '39827',
            '40198',
            '40242',
            '40370',
            '40377',
            '40417',
            '40426',
            '40427',
            '40431',
            '40461',
            '40462',
            '40469',
            '40470',
            '40471',
            '40476',
            '40486',
            '40557',
            '40580',
            '40790',
            '40797',
            '40995',
            '41004',
            '41027',
            '41076',
            '41078',
            '41161',
            '41287',
            '41333',
            '41343',
            '41348',
            '41351',
            '41365',
            '41386',
            '41388',
            '41421',
            '41550',
            '41551',
            '41602',
            '41603',
            '41661',
            '41668',
            '41678',
            '41699',
            '41742',
            '41879',
            '41957',
            '42023',
            '42129',
            '42254',
            '42327',
            '42355',
            '42360',
            '42365',
            '42386',
            '42387',
            '42414',
            '42562',
            '42641',
            '42731',
            '42823',
            '42857',
            '42885',
            '42943',
            '42999',
            '43042',
            '43551',
            '43619',
            '43622',
            '43634',
            '43641',
            '43761',
            '43762',
            '43778',
            '43782',
            '43995',
            '44000',
            '44006',
            '44008',
            '44026',
            '44028',
            '44031',
            '44038',
            '44042',
            '44048',
            '44050',
            '44054',
            '44059',
            '44063',
            '44065',
            '44072',
            '44077',
            '44078',
            '44080',
            '44083',
            '44086',
            '44090',
            '44091',
            '44111',
            '44127',
            '44131',
            '44139',
            '44146',
            '44158',
            '44165',
            '44167',
            '44181',
            '44183',
            '44188',
            '44210',
            '44274',
            '44284',
            '44290',
            '44296',
            '44300',
            '44307',
            '44313',
            '44321',
            '44322',
            '44338',
            '44341',
            '44350',
            '44353',
            '44354',
            '44367',
            '44382',
            '44383',
            '44388',
            '44396',
            '44399',
            '44403',
            '44414',
            '44438',
            '44440',
            '44460',
            '44479',
            '44501',
            '44504',
            '44505',
            '44514',
            '44516',
            '44535',
            '44658',
            '44659',
            '44662',
            '44672',
            '44711',
            '44712',
            '44746',
            '44776',
            '44790',
            '44819',
            '44822',
            '44828',
            '44829',
            '44830',
            '44837',
            '44850',
            '44868',
            '44903',
            '44920',
            '45002',
            '45068',
            '45074',
            '45118',
            '45150',
            '45158',
            '45184',
            '45188',
            '45315',
            '45365',
            '45372',
            '45405',
            '45406',
            '45410',
            '45611',
            '45676',
            '45678',
            '45684',
            '45703',
            '45716',
            '45728',
            '45730',
            '45748',
            '45868',
            '45873',
            '45874',
            '45891',
            '45900',
            '45901',
            '45902',
            '45906',
            '45930',
            '45971',
            '46153',
            '46164',
            '46286',
            '46309',
            '46341',
            '46349',
            '46534',
            '46539',
            '46587',
            '46613',
            '46679',
            '46695',
            '46697',
            '46972',
            '46993',
            '46995',
            '47030',
            '47061',
            '47066',
            '47081',
            '47084',
            '47110',
            '47159',
            '47160',
            '47204',
            '47223',
            '47409',
            '47510',
            '47543',
            '47581',
            '47592',
            '47594',
            '47708',
            '47909',
            '48129',
            '48477',
            '48755',
            '48761',
            '48769',
            '48925',
            '49146',
            '49213',
            '49219',
            '49224',
            '49262',
            '49264',
            '49560',
            '49829',
            '49841',
            '49959',
            '49966',
            '49986',
            '49990',
            '49992',
            '50026',
            '50049',
            '50268',
            '50893',
            '50989',
            '51048',
            '51133',
            '51312',
            '51348',
            '51359',
            '51441',
            '51510',
            '51659',
            '51955',
            '52212',
            '52220',
            '52411',
            '52421',
            '52439',
            '52441',
            '52442',
            '52443',
            '52444',
            '52446',
            '52450',
            '52451',
            '52453',
            '52454',
            '52456',
            '52459',
            '52461',
            '52916',
            '53103',
            '53696',
            '53808',
            '55228',
            '55268',
            '56138',
            '56557',
            '56564',
            '57908',
            '58021',
            '58058',
            '58069',
            '58089',
            '58320',
            '58630',
            '58680',
            '59532',
            '63471',
            '63472',
            '63473',
            '63489',
            '63537',
            '65227',
            '66738',
            '67848',
            '68734',
            '70090',
            '70401',
            '72072',
            '73166',
            '77154',
            '77162',
            '77177',
            '78736',
            '78829',
            '80224',
            '80226',
            '80234',
            '80261',
            '80551',
            '80552',
            '80553',
            '80554',
            '80561',
            '80562',
            '81069',
            '81096',
            '81133',
            '83786',
            '83789',
            '83986',
            '83988',
            '83989',
            '84251',
            '84279',
            '84323',
            '85030',
            '85630',
            '85631',
            '85632',
            '85633',
            '85634',
            '85635',
            '85636',
            '85637',
            '85638',
            '85639',
            '86071',
            '86078',
            '86385',
            '86387',
            '86389',
            '86397',
            '86442',
            '86446',
            '86463',
            '86836',
            '86838',
            '86866',
            '86873',
            '86874',
            '87258',
            '87274',
            '87280',
            '87338',
            '87406',
            '87588',
            '88420',
            '88672',
            '89910',
            '90768',
            '90771',
            '90773',
            '90774',
            '90776',
            '90778',
            '90780',
            '90782',
            '90784',
            '90785',
            '90788',
            '90791',
            '90793',
            '90796',
            '90987',
            '90993',
            '91151',
            '91152',
            '91154',
            '91156',
            '91157',
            '91158',
            '91159',
            '91161',
            '91162',
            '91163',
            '91254',
            '91255',
            '91256',
            '91257',
            '91258',
            '91261',
            '91264',
            '91303',
            '91304',
            '92185',
            '92412',
            '92725',
            '93914',
            '93964',
            '95509',
            '95519',
            '96044',
            '96981',
            '97500',
            '98181',
            '98626',
            '98627',
            '98715',
            '98716',
            '98718',
            '98719',
            '98721',
            '98722',
            '98724',
            '98725',
            '98759',
            '98762',
            '98767',
        ];
    }
}